Python Untuk TI

Python untuk TI-Nspire™
Program dan game Python yang andal untuk kalkulator teknologi TI-Nspire™ CX II
oleh
John Clark Craig
pengantar
Mengapa Python?
Python, bahasa pemrograman paling populer di dunia, adalah bahasa yang ideal untuk
kalkulator genggam. Sintaksnya ringkas, mudah dibaca, dan mudah dipahami, bahkan untuk
pemula. Bahasanya tidak berpemilik, sehingga dapat berjalan di mana-mana, bahkan di komputer
desktop dan laptop dengan hanya sedikit modifikasi dari apa yang akan Anda temukan di buku
ini, dan itu pun hanya dalam beberapa kasus.
Python menangani pemrosesan angka dengan baik, dan dengan daftar, string, dan struktur
data lainnya, Python menangani berbagai tugas pemrograman dengan sangat baik. Tetapi
mungkin keuntungan terbesar dari mempelajari Python melalui kalkulator yang dapat diprogram
adalah bahwa pengetahuan ini akan dapat diterapkan dan berguna, apa pun komputer atau sistem
yang mungkin Anda gunakan di masa depan. Pelajari sekali dan Anda akan memiliki
keterampilan hidup baru yang sangat berharga.
Python di kalkulator Anda
Sebagian besar pemrosesan angka yang terjadi dalam program Python sangat mudah dan
mudah dimengerti. Ketika berinteraksi dengan pengguna untuk meminta input dan output (biasa
disebut sebagai I/O) ada beberapa pendekatan opsional, dan memahami beberapa di antaranya
memudahkan Anda membuat program yang lebih pendek, atau program yang lebih panjang
tetapi lebih ramah pengguna , tergantung pada gaya dan tujuan pemrograman Anda. Program-
program dalam buku ini menggunakan beberapa pendekatan ini, dan penting untuk diketahui
bahwa Anda dapat mengubah program-program ini jika Anda lebih menyukai satu jenis
pemrograman daripada yang lain.
Cara terbaik untuk memanfaatkan Python di kalkulator Anda adalah dengan

mendefinisikan fungsi dalam file "program". Ketika Anda menjalankan program, tidak ada yang
terlihat terjadi. Tetapi definisi fungsi secara efektif ditambahkan ke kotak alat kalkulator Anda,
siap untuk Anda gunakan saat bekerja di shell. Misalnya, inilah isi program yang sangat singkat
yang mendefinisikan fungsi bernama add().
def add(x,y):
return x+y
Setelah Anda menjalankan program ini, di shell Anda dapat mengetikkan sesuatu seperti
"add(3,4)" untuk mendapatkan 7, atau untuk menambahkan dua angka atau variabel secara
bersamaan. Fungsi yang lebih rumit dapat menambahkan beberapa kemampuan baru yang kuat
ke kotak peralatan komputasi Anda!
Banyak program dalam buku ini dibuat sebagai kumpulan definisi fungsi dengan cara
ini. Ini membuat program sangat pendek dan lebih mudah untuk masuk. Dalam beberapa kasus,
program juga mencetak beberapa instruksi dan pengingat tentang cara menggunakan fungsi,
untuk referensi mudah. Lihatlah program vektor di dekat akhir bab 6 untuk contoh yang baik
tentang bagaimana menambahkan instruksi yang berguna, sementara hanya mendefinisikan
fungsi untuk digunakan nanti di shell.
Cara standar untuk membuat program mandiri di sebagian besar bahasa pemrograman
adalah dengan meminta pengguna memasukkan data, dan kemudian memproses data itu dengan
cara yang berarti untuk membuat keluaran bagi pengguna. Sepanjang buku ini ada beberapa
program di mana Anda diminta untuk mengetikkan data sebagai tanggapan terhadap prompt pada
saat run time, dan kemudian perhitungan dimulai. Lihatlah program bilangan prima, juga di bab
6, untuk contoh di mana program meminta Anda memasukkan titik awal untuk mencari bilangan
prima, dan jumlah bilangan prima yang harus ditemukan.
Ada beberapa trik I/O berguna lainnya yang disajikan dalam beberapa program dalam
buku ini. Terkadang berguna untuk meminta nomor, tetapi membiarkan pengguna cukup
menekan [enter] tanpa memasukkan nomor jika mereka tidak mengetahui nilainya. Ini
sebenarnya adalah hal yang rumit untuk dilakukan, karena penugasan sederhana ke variabel
setelah pemanggilan fungsi input() dapat gagal tanpa input apa pun. Perhatikan baik-baik
program arc_parts, di bab 8 untuk contoh di mana kombinasi dua dari empat variabel dapat
dimasukkan, dan variabel yang hilang akan dihitung. Berikut adalah sepasang baris kode di mana
sudut dimasukkan, atau nilai nol ditempatkan jika pengguna cukup menekan [enter].
a=input("Angle (deg): ")
a=float(a) if a else 0
Belajar dengan Contoh
Ada banyak, banyak sumber daya online dan di buku lain untuk mempelajari seluk-beluk
bahasa Python. Tujuan buku ini bukan untuk menduplikasi semua informasi ini. Sebaliknya, ada
banyak program pendek dan berguna yang dapat Anda gunakan "langsung dari kotak", dan
dengan menggunakannya, Anda akan belajar banyak tentang Python secara tidak langsung.
Jika Anda mencari tutorial pemula mutlak untuk membantu Anda mendapatkan kecepatan
dengan pemrograman dengan Python pada kalkulator teknologi TI-Nspire CX II Anda, ada situs
web luar biasa oleh Texas Instruments berjudul "10 Minutes of Code: Python". Saya sarankan
untuk melihat pelajaran membangun keterampilan ini. Ini tautannya:
https://education.ti.com/en/activities/ti-codes/python
Setiap kali Anda menemukan perintah yang terlihat sedikit misterius, saya sangat
menyarankan Anda Google untuk informasi lebih lanjut. Menurut pendapat saya, ini adalah cara
yang lebih baik untuk mempelajari banyak teknik pemrograman Python, dengan menggunakan
dan mengalami perintah dalam tindakan.
Misalnya, saya butuh beberapa saat untuk menemukan fungsi zip() Python yang
berguna. Saya menggunakannya di beberapa tempat dalam program vektor untuk membuat
fungsi vektor yang sangat ringkas dan kuat. Buka Google di "Python zip", pelajari cara kerjanya,
dan kemudian Anda akan mendapatkan pemahaman yang sangat baik tentang cara kerja fungsi
vektor add() untuk vektor 2d, 3d, atau bahkan lebih besar.
Kalkulator teknologi TI-Nspire™ CX II Anda adalah alat pembelajaran yang sangat kuat,
dan dengan tambahan Python, kapabilitas pengembangan pikirannya benar-benar mengagumkan!
1.
Tanggal dan Waktu
Berapa umurmu hari ini? Lain kali seseorang menanyakan pertanyaan ini kepada Anda,
Anda dapat menjawab dengan jumlah hari yang tepat daripada hanya membulatkan ke jumlah
tahun. Kemudian, untuk membuat mereka lebih terkesan, pastikan untuk dengan santai
menyebutkan hari dalam seminggu Anda dilahirkan.
Ini adalah jenis pertanyaan yang program dalam bab ini akan membiarkan Anda menjawab
dengan mudah.
kalender
Program ini membuat kalender satu halaman satu bulan yang bagus untuk bulan apa pun
selama periode beberapa abad.
Inti dari program ini adalah fungsi yang mengembalikan Nomor Hari Julian untuk tanggal
apa pun dalam rentang tahun dari 1582 hingga 4000. Fungsi ini, bernama jd(), dijelaskan lebih
rinci nanti dalam bab ini, tetapi ini dia digunakan untuk menentukan jumlah hari dalam bulan
tertentu, dan hari dalam seminggu untuk tanggal apa pun. Dari informasi ini kami dapat
memformat semua hari dalam bulan tertentu menjadi kalender satu bulan yang mudah dibaca.
Penerbangan pertama Wilbur dan Orville Wright yang lebih berat dari udara terjadi pada
pagi hari tanggal 17 Desember 1903 di Kitty Hawk, North Carolina. Kita dapat menjalankan
program ini untuk melihat tata letak satu bulan penuh Desember 1903 dan dengan mudah
menentukan bahwa tanggal 17 adalah hari Kamis.
from ti_draw import *
def jd(m,d,y):
if m<3:
y-=1
m+=12
a=int(y/100)
b=2-a+int(a/4)
e=int(365.25*(y+4716))
f=int(30.6001*(m+1))
return b+d+e+f-1524.5
# Get month and year

m=int(input("Month (1-12): "))
y=int(input("Year (1582-4000): "))
d1=int(jd(m,1,y))
dw=(d1+2)%7
m2=m+1 if m<12 else 1
y2=y if m<12 else y+1
d2=int(jd(m2,1,y2))
dm=d2-d1
mo=["Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec"]
# Set spacing
lt,tp,rs,cs=35,40,20,35
# Month, Year caption

s="{} {}".format(mo[m-1],y)
draw_text(lt+cs*2.5,tp-rs//2,s)
# Days of the week

draw_text(lt,tp+rs,"Sun")
draw_text(lt+cs,tp+rs,"Mon")
draw_text(lt+cs*2,tp+rs,"Tue")
draw_text(lt+cs*3,tp+rs,"Wed")
draw_text(lt+cs*4,tp+rs,"Thu")
draw_text(lt+cs*5,tp+rs,"Fri")
draw_text(lt+cs*6,tp+rs,"Sat")
# Day numbers
n=0
y=tp+rs*2
while n<dm:
n+=1
x=lt+cs*dw
s="{:3d}".format(n)
draw_text(x,y,s)
dw=(dw+1)%7
if dw==0:
y+=rs
tanggal
Program ini menggunakan fungsi Julian Day Number untuk menghitung hari dalam
seminggu dan hari dalam setahun untuk tanggal dalam rentang tahun dari 1582 hingga 4000.
Fungsi jd() dijelaskan secara lebih rinci di bagian lain bab ini.
Misalnya, 17 Desember 1903 (hari Orville dan Wilbur melakukan penerbangan lebih berat
dari udara pertama mereka) adalah hari Kamis, dan itu adalah hari ke 351 dalam setahun, seperti
yang ditunjukkan pada output berikut di Python Shell.
Hari dalam setahun ditemukan dengan mengurangkan Nomor Hari Julian untuk 31
Desember tahun sebelumnya dari Nomor Hari Julian hari yang dipilih.
def jd(m,d,y):
if m<3:
y-=1
m+=12
a=int(y/100)
b=2-a+int(a/4)
e=int(365.25*(y+4716))
f=int(30.6001*(m+1))

d=int(input("Day (1-31): "))
y=int(input("Year (1582-4000): "))
dj=int(jd(m,d,y))
dn=(dj+2)%7
dw=["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]
print("\n{}/{}/{}".format(m,d,y))
print("Day of week: ",dw[dn])
dy=dj-int(jd(12,31,y-1))
print("Day of year: ",dy)
tanggal_tambah_hari
Program ini menghitung tanggal yang merupakan jumlah hari tertentu yang ditambahkan
ke tanggal mulai. Misalnya, penerbangan pertama Wright bersaudara terjadi pada 17 Desember
1903. Tanggal berapa 40.000 hari di masa depan dari hari itu? Seperti yang ditunjukkan pada
output, 22 Juni 2013 adalah tanggal "jalan keluar di masa depan" sejak orang pertama kali
mengudara.
Jika Anda bertanya-tanya, ya, Anda dapat menambahkan jumlah hari negatif untuk
menemukan tanggal yang lebih awal.
Untuk melakukan perhitungan ini, tanggal mulai dikonversi ke Nomor Hari Julian
menggunakan fungsi jd(), jumlah hari ditambahkan untuk membuat Nomor Hari Julian kedua,
dan fungsi mdy() mengonversi angka itu kembali menjadi tanggal. Angka Hari Julian secara
otomatis menangani tahun kabisat, jumlah hari yang bervariasi dalam bulan, dan semua detail
itu. Kedua fungsi ini dijelaskan lebih rinci dalam program julian di bab ini.
from math import *
def jd(m,d,y):
if m<3:
y-=1
m+=12
a=int(y/100)
b=2-a+int(a/4)
e=int(365.25*(y+4716))
f=int(30.6001*(m+1))
def mdy(jd):
z=int(jd+.5)
f=jd+.5-z
if z<2299161:
a=z
else:
t=int((z-1867216.25)/36524.25)
a=z+1+t-int(t/4)
b=a+1524
c=int((b-122.1)/365.25)
g=int(365.25*c)
e=int((b-g)/30.6001)
d=int(b-g-int(30.6001*e)+f)
if e<14:
m=e-1
else:
m=e-13
if m>2:
y=c-4716
else:
y=c-4715
return [m,d,y]

y=int(input("Year (1582-4000): "))
n=int(input("Number of days: "))
m,d,y=mdy(jd(m,d,y)+n)
print("{0}/{1}/{2}".format(m,d,y))
julian
Program ini mendemonstrasikan dua fungsi yang sangat berguna untuk berbagai
perhitungan kalender. Semua program lain dalam bab ini menggunakan salah satu atau kedua
fungsi ini.
jd() menghitung Angka Hari Julian untuk tanggal tertentu dalam rentang tahun 1582
hingga 4000. Ini adalah angka hari mutlak yang digunakan oleh para astronom dan lainnya untuk
secara jelas menentukan urutan setiap hari, tanpa memperhatikan tahun kabisat dan komplikasi
lain semacam itu.
Perhatikan bahwa karena alasan historis, setiap hari astronomi dimulai pada tengah hari
waktu Greenwich, jadi ada tambahan ".5" pada Angka Hari Julian ini. Dalam program yang
disajikan di sini kami menambahkan dan mengurangi seluruh hari untuk menemukan tanggal
relatif, dan bagian pecahan ekstra ini tidak terlalu penting. Untuk perhitungan astronomi, bagian
pecahan ini menjadi penting.
Fungsi mdy() menyediakan cara untuk mengonversi Nomor Hari Julian kembali ke triplet
angka untuk bulan, hari, dan tahun untuk tanggal tersebut. Ini memudahkan untuk menambah
dan mengurangi hari untuk mendapatkan tanggal baru secara akurat, tanpa harus melakukan
penyesuaian rumit untuk jumlah hari dalam setiap bulan, atau untuk tahun kabisat.
Kode contoh memasukkan tanggal dan menampilkan Nomor Hari Julian. Selanjutnya,

setiap Nomor Hari Julian dimasukkan dan tanggal kalender untuk hari itu dikeluarkan. Seperti
yang ditunjukkan, 17 Desember 1903 memiliki Hari Julian Nomor 2.416.465.5 dan Hari Julian
Nomor 2.500.000.5 akan jatuh pada tanggal 1 September di tahun 2132.
from math import *
def jd(m,d,y):
if m<3:
y-=1
m+=12
a=int(y/100)
b=2-a+int(a/4)
e=int(365.25*(y+4716))
f=int(30.6001*(m+1))
def mdy(jd):
z=int(jd+.5)
f=jd+.5-z
if z<2299161:
a=z
else:
t=int((z-1867216.25)/36524.25)
a=z+1+t-int(t/4)
b=a+1524
c=int((b-122.1)/365.25)
g=int(365.25*c)
e=int((b-g)/30.6001)
d=int(b-g-int(30.6001*e)+f)
if e<14:
m=e-1
else:
m=e-13
if m>2:
y=c-4716
else:
y=c-4715
return [m,d,y]

y=int(input("Year (1582-4000): "))
j=jd(m,d,y)
print("Julian Day: ",j)
j=float(input("Julian Day: "))
m,d,y=mdy(j)
print("{0}/{1}/{2}".format(m,d,y))
hari_antara_tanggal
Berapa hari Anda akan berada di Bumi pada hari ulang tahun Anda
berikutnya? Pertanyaan semacam ini mudah dijawab dengan program ini. Dua tanggal
dimasukkan, diubah menjadi Julian Day Numbers, dan selisih di antara keduanya dihasilkan
sebagai jumlah hari di antara kedua tanggal tersebut.
Fungsi jd() adalah inti dari program ini. Ini dijelaskan secara lebih rinci dalam program
julian yang disajikan dalam bab ini.
Perhitungan sampel menemukan jumlah hari dari hari Orville dan Wilbur melakukan
penerbangan pertama mereka (17 Desember 1903) dan tanggal Y2K, atau 1 Januari 2000.
Hasilnya adalah 35.079 hari tepatnya.
def jd(m,d,y):
if m<3:
y-=1
m+=12
a=int(y/100)
b=2-a+int(a/4)
e=int(365.25*(y+4716))
f=int(30.6001*(m+1))
print("\nFirst date")
m1=int(input("Month (1-12): "))
d1=int(input("Day (1-31): "))
y1=int(input("Year (1582-4000): "))
print("\nSecond date")
m2=int(input("Month (1-12): "))
d2=int(input("Day (1-31): "))
y2=int(input("Year (1582-4000): "))
nd=int(abs(jd(m1,d1,y1)-jd(m2,d2,y2)))
print("\n{}/{}/{}".format(m1,d1,y1))
print("{}/{}/{}".format(m2,d2,y2))
print("Days between: ",nd)
jam
Kalkulator teknologi TI-Nspire™ CX II Anda mampu menampilkan beberapa grafik

warna yang sangat bagus, dan modul ti_draw memungkinkan semuanya. Program ini
mendemonstrasikan sebagian besar perintah grafis yang tersedia, yang digunakan di sini untuk
membuat tampilan jam analog animasi yang menandai detik secara visual.
Tiga modul lainnya diimpor untuk mengaktifkan fitur program ini. Modul matematika
memungkinkan kita menggunakan fungsi trigonometri untuk menggambar jarum jam pada sudut
yang benar seiring berjalannya waktu. Modul waktu diperlukan untuk mengakses waktu internal
kalkulator Anda. Modul ti_system menyediakan cara untuk menggambar ulang tampilan jam
setiap detik sampai Anda menekan tombol Esc untuk menghentikannya.
Saya sarankan untuk melihat lebih dekat pada fungsi dan baris kode lain dari program ini,
pastikan Anda memahami cara kerja setiap perintah dan fungsi. Saya telah menambahkan
beberapa baris komentar untuk membantu Anda. Jika Anda benar-benar "mengambil" kode ini,
Anda akan memiliki pegangan yang sangat baik tentang cara memprogram kreasi Anda sendiri
yang luar biasa dan mengesankan!
Perhatikan baik-baik panggilan fungsi use_buffer(), paint_buffer(), dan clear(). Ini secara

drastis mempercepat grafik, dengan melakukan semua gambar di memori di suatu tempat, dan
kemudian secara instan memperbarui seluruh gambar yang sudah selesai ke layar setiap
detik. Animasi apa pun yang Anda buat akan bekerja jauh lebih baik jika Anda menggunakan
buffer latar belakang dengan cara ini.
from math import *
from time import *
from ti_system import *
# Rotate a point by a degrees

def rotate(p,a):
x,y=p
r=radians(a)
xr=x*cos(r)-y*sin(r)
yr=x*sin(r)+y*cos(r)
return (xr,yr)
# Initialize clock face

use_buffer()
ratio=318/212
scale=1.1
xr=scale*ratio
yr=scale
set_window(-xr,xr,-yr,yr)
rfa=1.0
rho=.5
rmi=.8
rse=.9
s,lasts=0,0
# Until escape key

while get_key() != "esc":
# Wait for next second
while s==lasts:
y,m,d,h,m,s,wd,yn,dst=localtime()
h%=12
lasts=s
# Draw face and numbers

set_pen(1,0)
set_color(0,0,0)
draw_circle(0,0,rfa)
for i in range(12):
hr=i+1
rad=2*atan(1)*(5-hr/3)
x=.86*cos(rad)-.04
y=.86*sin(rad)-.1
draw_text(x,y,hr)
# Draw second marks

set_pen(0,0)
for i in range(60):
rad=8*atan(1)*i/60
x=.97*cos(rad)
y=.97*sin(rad)
shp=3 if i%5 else 1
plot_xy(x,y,shp)

# Draw hour hand
set_color(0,127,0)
sx=[-.15,-.15,.5,.5]
sy=[.03,-.03,-.01,.01]
for i in range(4):
p=[sx[i],sy[i]]
a=90-30*(h+m/60)
sx[i],sy[i]=rotate(p,a)
fill_poly(sx,sy)

# Draw minute hand
set_color(0,0,255)
sx=[-.15,-.15,.7,.7]
sy=[.03,-.03,-.01,.01]
for i in range(4):
p=[sx[i],sy[i]]
a=90-6*m
fill_poly(sx,sy)

# Draw second hand
set_color(255,0,0)
sx=[-.15,-.15,.8,.8]
sy=[.03,-.03,-.01,.01]
for i in range(4):
p=[sx[i],sy[i]]
a=90-6*s
fill_poly(sx,sy)
# Update the display

paint_buffer()
clear()
2.
Elektronik
Bab ini menyajikan contoh program yang berguna untuk melakukan berbagai perhitungan
elektronik. Penulis telah menggunakan perhitungan ini dan yang serupa ketika menciptakan
beberapa gadget yang menyenangkan, seperti lampu rem sepeda yang tidak memerlukan kabel,
Anda cukup menempelkannya di sepeda atau helm dan mengendarainya! Ini menggunakan
akselerometer dan beberapa kode program yang menyenangkan untuk menghilangkan gundukan
dan rotasi saat mendeteksi pengereman dan menyalakan lampu rem yang
terang. (LucidBrakes™)
Apakah Anda bereksperimen dengan Arduino, Raspberry Pis, atau membuat sirkuit Anda
sendiri di tingkat komponen, perhitungan ini bisa sangat berguna.
rata_puncak_rms
Rumah-rumah di Amerika Serikat dialiri daya listrik berupa gelombang sinus dengan
tegangan efektif sekitar 117 volt. Tegangan efektif ini memberikan daya yang sama dalam watt
ke beban resistif seperti tegangan DC 117 volt. Tegangan efektif juga disebut RMS, yang
merupakan singkatan dari "Root-Mean-Squared", karena cara menurunkannya secara matematis.
Sebagian besar waktu kita menggunakan nilai tegangan efektif, karena itu adalah nilai
yang memungkinkan perhitungan cepat daya ke rangkaian. Tetapi ada dua cara lain untuk
mengukur tegangan gelombang sinus. Tegangan puncak, pada titik paling atas dari gelombang
sinus, memberikan nilai tegangan "Puncak", dan besarnya rata-rata tegangan dari waktu ke
waktu, tanpa memperhatikan polaritas, memberikan nilai tegangan "Rata-rata".
Berikut adalah dua persamaan konversi utama. Semua hubungan antara tegangan Puncak,
Rata-Rata, dan RMS dapat diketahui dengan bekerja secara aljabar dengan keduanya:
Program ini menyediakan konversi antara ketiga cara untuk menggambarkan tegangan
gelombang sinus murni. Masukkan satu nilai yang diketahui saat diminta, dan cukup tekan
[enter] untuk melewati dua lainnya. Program menentukan nilai mana yang Anda masukkan,
menghitung dua lainnya, dan menampilkan ketiganya untuk referensi mudah.
from math import *
def ac_voltages(avg,peak,rms):
if avg:
peak=pi*avg/2
rms=peak/sqrt(2)
elif peak:
avg=peak*2/pi
rms=peak/sqrt(2)
elif rms:
peak=rms*sqrt(2)
avg=peak*2/pi
return [avg,peak,rms]
print("\n\nInput one AC voltage type\n")

s=input("Average: ")
avg=float(s) if s else 0
s=input("Peak: ")
peak=float(s) if s else 0
s=input("RMS: ")
rms=float(s) if s else 0
avg,peak,rms=ac_voltages(avg,peak,rms)
print("\nAvg: ",avg)
print("Peak: ",peak)
print("RMS: ",rms)
Seperti yang ditunjukkan dalam contoh ini, tegangan kabel rumah standar AS sebesar 117
V (RMS) memiliki tegangan puncak sekitar 165 V, dan tegangan rata-rata dari waktu ke waktu
sekitar 105 V.
menjembatani
Sirkuit jembatan seimbang, juga disebut jembatan Wheatstone, digunakan dalam
elektronik untuk pengukuran presisi dan untuk tujuan lain. Perhitungan umum adalah
menemukan nilai satu kaki jembatan seimbang ketika tiga kaki lainnya diketahui. Sebagai
contoh, pada gambar berikut kita dapat menghitung nilai untuk R4 ketika R1, R2, dan R3
diketahui. Nilai-nilai ini menyebabkan ammeter di tengah membaca nol amp. Demikian pula,
voltmeter di dua simpul yang sama ini akan membaca nol volt.
Berikut persamaan yang menghubungkan keempat resistor tersebut:
Perhatikan bahwa fungsi bridge() menggunakan variabel z1 hingga z3, bukan R1 hingga
R3. Ini karena fitur Python yang luar biasa, di mana variabel dapat dengan mudah berisi bilangan
kompleks seperti halnya bilangan real. Dalam analisis rangkaian, bilangan kompleks sangat
berguna untuk rangkaian AC yang mengandung kapasitor dan induktor selain resistor. Dan ya,
rangkaian jembatan AC mengikuti semua aturan matematika yang sama saat bekerja dengan
komponen ini, menggunakan bilangan kompleks untuk impedansi masing-masing.
Contoh berikut menghitung nilai resistansi kaki ke-4 ketika tiga resistor pertama adalah
2700, 3900, dan 5600 ohm, dan ini memecahkan kedua kalinya untuk impedansi kompleks 4+3j,
5+0j, dan 3-7j.
def bridge(z1,z2,z3):
return z1*z3/z2
r1=2700
r2=3900 # opposite the unknown
r3=5600
r4=bridge(r1,r2,r3)
print("r1: ",r1)
print("r2: ",r2)
print("r3: ",r3)
print("bridge(r1,r2,r3): ",r4)
z1=4+3j
z2=5+0j # opposite the unknown
z3=3-7j
z4=bridge(z1,z2,z3)
print("z1: ",z1)
print("z2: ",z2)
print("z3: ",z3)
print("bridge(z1,z2,z3): ",z4)
Fungsi bridge() sangat kecil, hanya dua baris kode pertama. Sebagian besar program ini
mendemonstrasikan pemanggilan fungsi bridge() dua kali, sekali untuk memecahkan jembatan
resistif murni, dan kedua kalinya untuk menyeimbangkan jembatan yang terdiri dari impedansi
bernilai kompleks.
Seperti yang ditunjukkan, resistor ke-4 dalam kasus pertama harus sekitar 3877 ohm, dan
impedansi dalam kasus kedua harus 6,6-3,8j ohm.
delta_wye
Ketika Anda menjalankan program ini, tidak ada yang terjadi. Oke, sedikit
penjelasannya. Seperti yang dijelaskan di awal buku ini, cara sederhana dan mudah untuk
menambahkan fungsi canggih ke kalkulator Anda adalah dengan mendefinisikan fungsi dalam
program yang dapat Anda gunakan berulang kali saat mengerjakan beberapa masalah yang
relevan. Dalam hal ini, dua fungsi didefinisikan pada saat run time, delta() dan wye(), dan
mereka tetap berada di shell yang siap untuk Anda gunakan.
Fungsi delta() mengonversi resistansi dalam konfigurasi wye ke konfigurasi delta yang
setara. Fungsi wye() melakukan konversi yang berlawanan untuk menghasilkan konfigurasi wye
yang setara dengan konfigurasi delta delta yang Anda berikan padanya.
Kedua fungsi ini juga berfungsi untuk impedansi bilangan kompleks, seperti yang
ditunjukkan dalam contoh. Ini adalah fitur yang kuat untuk analisis elektronik yang lebih maju.
Konfigurasi delta disebut demikian karena ketiga resistor disusun dalam segitiga,
meskipun diagram rangkaian sering menunjukkan mereka lebih dari pengaturan pi, seperti yang
ditunjukkan di sini di sebelah kiri. Perhatikan bahwa jika Anda "menggabungkan" bagian bawah
RB dan RC, sebuah segitiga akan terbentuk.
Demikian pula, konfigurasi wye sering ditampilkan sebagai pengaturan "T", seperti yang
ditunjukkan di sini di sebelah kanan. Bayangkan saja titik tengah antara R1, R2, dan R3 ditarik
sedikit ke bawah dan Anda akan melihat bentuk "Y", atau wye.
Fungsi delta() menggunakan persamaan berikut untuk menemukan nilai RA, RB, dan RC
yang membentuk rangkaian resistansi, atau impedansi yang setara, jika diberikan R1, R2, dan
R3.
Fungsi wye() menggunakan persamaan berikut untuk menemukan nilai untuk R1, R2, dan
R3 yang membentuk rangkaian resistansi, atau impedansi yang setara, jika diberikan RA, RB,
dan RC.
Beberapa baris kode pertama dalam program mendefinisikan fungsi delta() dan wye()
ini. Saya telah menambahkan perintah print() opsional di akhir daftar untuk mengingatkan Anda
saat runtime bagaimana memanggil masing-masing. Ini adalah cara yang baik untuk
mendokumentasikan sendiri fungsi yang didefinisikan, tetapi tidak benar-benar dipanggil saat
runtime.
def delta(z1,z2,z3):
tmp=z1*z2+z2*z3+z3*z1
return tmp/z1,tmp/z2,tmp/z3
def wye(za,zb,zc):
tmp=za+zb+zc
return zb*zc/tmp,za*zc/tmp,za*zb/tmp
print("\nDelta to Wye (R or Z)")

print("wye(za,zb,zc)")
print("\nWye to Delta (R or Z)")
print("delta(z1,z2,z3)")
Inilah yang ditampilkan segera setelah program dijalankan untuk memuat fungsi ke dalam
shell. Seperti yang Anda lihat, belum ada perhitungan yang benar-benar terjadi. Fungsi-fungsi
baru telah dimuat dan siap digunakan.
Inilah hasil pemanggilan setiap fungsi. Dalam kasus pertama kami mengubah resistansi
dalam konfigurasi wye 300, 400, dan 500 ohm ke konfigurasi delta yang setara. Hasilnya adalah
sekitar 1567, 1175, dan 940 ohm. Panggilan kedua mengubah impedansi 4+3j, 5, dan 3-7j ohm
dari konfigurasi delta ke nilai wye yang setara. Hasilnya adalah nilai kompleks 2-2.25j, 2.95-
0.6j, dan 1.125+1.625j ohm.
frekuensi_panjang gelombang
Spektrum elektromagnetik mencakup berbagai fenomena, seperti gelombang radio, sinar-

x, cahaya tampak, cahaya infra merah, gelombang mikro, dan sebagainya. Masing-masing fitur
ini jatuh ke dalam pita frekuensi, setiap frekuensi memiliki panjang gelombang tertentu, dan
semuanya bergerak di ruang bebas dengan kecepatan cahaya.
Frekuensi dalam Hertz dan Panjang gelombang dalam meter adalah kebalikan dari satu
sama lain. Keduanya merupakan fungsi dari kecepatan cahaya. Inilah persamaan paling
sederhana yang mengikat semua ini bersama-sama, di mana C adalah kecepatan cahaya:
Sebagian besar waktu, panjang gelombang dan frekuensi dinyatakan dalam notasi teknik,
di mana pangkat sepuluh adalah kelipatan tiga. Notasi ini mudah diubah menjadi awalan seperti
kilo, Mega, nano, dan lain-lain, sehingga lebih mudah untuk menangkap besaran nilainya. Fungsi
pertama dalam program ini, bernama eng(), memformat angka menjadi notasi teknik dengan
jumlah digit signifikan yang diinginkan. Anda mungkin ingin mengisolasi fungsi ini ke dalam
modul untuk digunakan dalam program lain yang Anda buat.
from math import *
def eng(x,d):
x=abs(x)
if x==0:
return "0.0"
exp=floor(log10(x))
mant=x/10**exp
r = round(mant,d-1)
x = r*pow(10.0,exp)
p = int(floor(log10(x)))
p3 = p//3
value=x/pow(10.0,3*p3)
s="{:f}".format(value)
if s[d]!=".":
s=s[0:d+1]
else:
s=s[0:d]
if p3!=0:
return "{}e{:d}".format(s,3*p3)
else:
return "{}".format(s)
c,f,w=299792458,0,0
print("\nEnter known value...")
f=input("Frequency: ")
f=float(f) if f else 0
if f==0:
w=input("Wavelength (m): ")
w=float(w) if w else 0
if w!=0:
f=c/w
if f!=0:
w=c/f
digits=5
print("\nFrequency:")
print("{} Hz".format(eng(f,digits)))
print("\nWavelength:")
print("{} meters".format(eng(w,digits)))
Program ini meminta frekuensi, kemudian untuk panjang gelombang jika Anda
melewatkan memasukkan nilai frekuensi dengan menekan [enter] tanpa memasukkan
angka. Nilai yang tidak diketahui dalam kedua kasus dihitung, kedua nilai diformat ke dalam
notasi teknik, dan hasilnya ditampilkan ke tampilan kalkulator Anda.
Dua contoh run ditampilkan, yang pertama di mana frekuensi diketahui, dan kedua di
mana panjang gelombang adalah nilai yang diketahui. Pada contoh pertama frekuensi Helium
"Jaringan Rakyat" untuk Internet of Things (IOT) dimasukkan untuk menghitung panjang
gelombangnya. 915 megahertz memiliki panjang gelombang kurang dari sepertiga meter.
Dalam contoh kedua ini kita melewatkan input frekuensi dan kemudian memasukkan 5
untuk menghitung frekuensi ketika panjang gelombang tepat 5 meter. Frekuensinya hanya sedikit
kurang dari 60 megahertz.
Perhatikan bahwa variabel bernama digit, di dekat akhir program, diatur ke lima. Ubah
nilai ini jika Anda menginginkan presisi yang lebih tinggi atau lebih rendah dalam jawaban
Anda.
Untuk referensi mudah, berikut adalah daftar awalan metrik untuk berbagai kekuatan
notasi teknik sepuluh:
led_resistor
LED mengagumkan. Setelah Anda tahu cara menyalakannya dengan benar, Anda dapat
menyalakan semua jenis karya seni, gadget, dan penemuan yang menyenangkan dalam warna
apa pun dan pola berkedip yang bisa dibayangkan. Misalnya, penulis menemukan lampu rem
untuk sepeda yang sama sekali tidak memerlukan kabel ke rem, melainkan mengandalkan chip
akselerometer untuk menentukan kapan harus menyalakan LED merah terang untuk
menunjukkan perlambatan. Lihat LucidBrakes™ online.
LED adalah jenis dioda khusus, di mana arus mengalir dengan mudah ke satu arah
melaluinya, dan bukan ke arah lain. Untuk menyalakan LED, Anda perlu menggunakan resistor
untuk membatasi jumlah arus yang diizinkan mengalir ke arah yang "mudah". Program ini
membantu Anda menghitung ukuran resistor itu. Ini juga membantu menentukan kebutuhan arus
dan daya, untuk memastikan tidak ada asap ajaib yang dipancarkan dari apa pun!
Cara standar untuk memasang LED adalah dengan resistor secara seri, dan sumber
tegangan memberi daya pada keduanya:
Berikut adalah persamaan yang menyatukan semua perhitungan yang kita perlukan dalam
program, di mana Vs adalah tegangan sumber, Vf adalah tegangan maju melintasi LED, Vr
adalah tegangan melintasi resistor, i adalah arus dalam amp yang melalui semuanya, Wr adalah
watt daya di resistor, dan Wf adalah watt daya di LED.
Berikut listing programnya:
def led_resistor(Vs,Vf,i):
r=(Vs-Vf)/i
Wr=(Vs-Vf)*i
Wl=Vf*i
return [r,Wr,Wl]
def led_current(Vs,Vf,r):
i=(Vs-Vf)/r
Wr=(Vs-Vf)*i
Wl=Vf*i
return [i,Wr,Wl]
Vs=float(input("Source Vs: "))

Vf=float(input("LED Vf: "))
print("\nNow enter one of these two...")
i=input("Current in amps: ")
i=float(i) if i else 0
r=input("LED resistor in ohms: ")
r=float(r) if r else 0
if i:
r,Wr,Wl=led_resistor(Vs,Vf,i)
else:
i,Wr,Wl=led_current(Vs,Vf,r)
print("\nVs: ",Vs)
print("Vf: ",Vf)
print("R: {} ohms".format(r))
print("i: {} amps".format(i))
print("Wres: {} watts".format(Wr))
print("Wled: {} watts".format(Wl))
Dua contoh berikut berjalan pertama-tama temukan nilai perkiraan untuk resistor ketika
arus diketahui, dan contoh kedua menghitung arus ketika resistor standar dipilih untuk rangkaian.
Dalam kedua kasus, Anda memasukkan tegangan sumber dan tegangan maju LED (Vf ini
bervariasi untuk jenis LED), dan kemudian memasukkan arus dalam amp atau nilai resistor
dalam ohm.
Untuk rangkaian yang ditenagai dengan 12 volt, LED dengan drop tegangan maju 2,4 volt
dengan arus 25 mA yang melaluinya memerlukan perkiraan ukuran resistor 384 ohm.
Proses selanjutnya, dengan sumber tegangan 9 volt dan penurunan tegangan maju LED
sebesar 2,3 volt dan nilai resistor standar 270 ohm, menghasilkan arus sekitar 24,8 miliampere.
Sangat penting untuk tidak membakar resistor atau LED di sirkuit Anda. Resistor memiliki
watt yang dinyatakan, dan akan baik-baik saja jika Wres kurang dari nilai ini. Dalam contoh kita,
resistor dipanaskan dengan daya sekitar 0,17 watt, jadi resistor seperempat watt (0,25 watt)
standar harus berfungsi dengan baik. LED memiliki arus maksimum yang dinyatakan, yang juga
dapat Anda periksa dengan hasil ini.
ohm_laws
Subyek listrik dan elektronika penuh dengan persamaan dan rumus, tetapi sejauh ini dua
persamaan yang paling penting adalah apa yang kita sebut "Hukum Ohm". Jika Anda hanya
mempelajari cara bekerja dengan dua persamaan sederhana berikut, Anda akan cukup tahu untuk
dianggap sebagai ahli elektronik oleh hampir semua orang yang Anda kenal.
Persamaan pertama menyatakan bahwa tegangan (gaya elektromagnetik) sama dengan

arus dalam ampere (I) kali hambatan dalam ohm (R). Persamaan kedua menyatakan bahwa watt
(Daya) sama dengan arus dalam ampere dikalikan tegangan.
Sangat mudah untuk mengatur ulang secara aljabar kedua persamaan ini untuk
menghitung yang tidak diketahui ketika ada dua nilai yang diketahui. Program ini meminta Anda
untuk memasukkan dua dari empat nilai ini, dua kuantitas lainnya akan dihitung, dan keempat
nilai akan menjadi output.
Program ini mendefinisikan fungsi bernama ohms_laws(), mencetak beberapa instruksi

untuk tinjauan Anda, dan kemudian berhenti. Sejak saat itu Anda memanggil fungsi baru untuk
menghitung keempat nilai ketika ada dua yang diketahui.
Misalnya, pertimbangkan bola lampu 60 watt yang ditenagai oleh rumah tangga standar
117 volt. Masukkan nol untuk dua yang tidak diketahui, arus dan hambatan, dan fungsi akan
menemukan nilai-nilai ini. Arus sekitar setengah amp, dan hambatan bola lampu sekitar 228
ohm.
def ohms_laws(p,i,e,r):
if p and i:
e=p/i
r=p/(i*i)
elif p and e:
i=p/e
r=(e*e)/p
elif p and r:
i=math.sqrt(p/r)
e=math.sqrt(p*r)
elif i and e:
p=i*e
r=e/i
elif i and r:
p=i*i*r
e=i*r
elif e and r:
p=(e*e)/r
i=e/r
else:
pass
return ([p,i,e,r])
print("ohms_laws(p,i,e,r)")
print("Pass two known values, and zeros")
print("for the other two unknowns.")
paralel
Resistor secara paralel dapat diganti dengan resistor ekivalen tunggal, teknik yang sering
digunakan dalam analisis rangkaian. Persamaan yang sama bekerja untuk impedansi secara
paralel juga, jadi program yang satu ini bekerja untuk resistansi atau impedansi bilangan
kompleks yang sama.
Resistansi setara (atau impedansi) dihitung dengan rumus berikut:
Berikut adalah sketsa yang menunjukkan bagaimana beberapa resistor dihubungkan secara
paralel:
Program mendefinisikan fungsi bernama parallel(), dan mencetak dua baris

instruksi. Perhatikan bahwa satu daftar nilai dilewatkan ke fungsi ini, memungkinkan sejumlah
resistansi atau impedansi paralel untuk diproses. Cukup tambahkan dua atau lebih ke daftar dan
berikan daftar ke fungsi ini.
Contoh menunjukkan bagaimana tanda kurung siku mendefinisikan daftar.

def parallel(zlist):
zp=sum(1/z for z in zlist)
return 1/zp
print("Parallel (R or Z)")
print("parallel(list)")
Contoh pertama menemukan resistor tunggal yang sama dengan tiga resistor secara
paralel, dan contoh kedua mengulangi perhitungan untuk daftar dua impedansi bilangan
kompleks.
Pastikan untuk "membungkus" tiga nilai resistor ke dalam daftar menggunakan tanda
kurung siku, seperti yang ditunjukkan. Fungsi ini mengharapkan hanya satu argumen, daftar, dan
meneruskannya tiga nomor terpisah menyebabkan kesalahan.
Hasilnya menunjukkan bahwa resistor 300, 400, dan 500 ohm secara paralel dapat diganti
dengan satu resistor sekitar 128 ohm.
Contoh berikut menghitung impedansi ekivalen untuk dua impedansi paralel, yang
pertama pada 300+400j, dan yang kedua pada 500-600j. Seperti yang ditunjukkan di sini,
impedansi ekivalen kira-kira 453+138j.
rc_timing
Banyak rangkaian pengaturan waktu yang umum didasarkan pada konfigurasi pengisian
daya RC, yang dasar-dasarnya ditunjukkan di sini:
Kapasitor C1 dimulai dengan tegangan pada Vi sama dengan V1. Tegangan awal V1 ini
seringkali nol, tetapi dapat berupa tegangan apa saja. Ketika tegangan input beralih ke tegangan
lain V2, kapasitor mulai mengisi saat arus mengalir ke (atau keluar) melalui R1. Dibutuhkan
waktu untuk tegangan pada Vi untuk naik (atau turun) sampai ke V2, dan rincian waktu
pengisian ini adalah tentang program ini.
Ada enam variabel dalam perhitungan ini; tegangan awal yang diterapkan V1, tegangan
yang diterapkan baru V2, tegangan sesaat Vi, jumlah detik S sejak tegangan yang diterapkan
diubah, dan nilai resistansi R dan kapasitansi C yang menentukan laju perubahan tegangan
sesaat. Semakin besar resistor, semakin lambat kapasitor akan mengisi. Semakin besar perbedaan
antara dua tegangan input semakin cepat tegangan kapasitor akan berubah. Dan
seterusnya. Berikut adalah persamaan yang menghubungkan semua parameter ini:
Program ini mendefinisikan fungsi bernama rc_timing() yang secara aljabar mengisolasi
setiap variabel dalam persamaan ini untuk menemukan nilainya ketika semua variabel lainnya
diketahui. Fungsi kedua, bernama rc() dirancang tidak untuk tujuan lain selain untuk membuat
entri dan tampilan hasil lebih sederhana dan lebih baik. Anda dapat menggunakan salah satu
fungsi untuk mendapatkan hasil yang sama, tetapi saya sarankan menggunakan rc().
def rc_timing(v1,v2,vi,C,R,t):
if not t:
tmp=-log((v2-vi)/(v2-v1))
t=tmp*R*C
elif not R:
R=t/C/tmp
elif not C:
C=t/R/tmp
elif not vi:
tmp=exp(-t/R/C)
vi=v2-tmp*(v2-v1)
elif not v2:
tmp=exp(-t/R/C)
v2=(tmp*v1-vi)/(tmp-1)
elif not v1:
tmp=exp(-t/R/C)
v1=(vi+v2*(tmp-1))/tmp
return [v1,v2,vi,C,R,t]
def rc(v1,v2,vi,C,R,t):
v1,v2,vi,C,R,t=rc_timing(v1,v2,vi,C,R,t)
print("v1: ",v1)
print("v2: ",v2)
print("vi: ",vi)
print("C: ",C)
print("R: ",R)
print("t: ",t)
print("rc(v1,v2,vi,C,R,t)")
print("Pass 0 for the unknown")
Saat Anda menjalankan program ini, dua fungsi ditentukan tetapi tidak ada tindakan lebih
lanjut yang diambil. Anda kemudian dapat mengetikkan fungsi rc() ke dalam shell, melewati
keenam parameter. Setiap satu, dan hanya satu, argumen harus nol, dan nilainya akan dihitung
menggunakan lima argumen lainnya.
Misalnya, dimulai dengan V1 pada 0 volt, kemudian menerapkan V2 sebesar 5 volt,

berapa lama waktu yang dibutuhkan tegangan Vi untuk naik menjadi 4 volt ketika resistor 47K
ohm dan kapasitor 6,8 mikrofarad? Sekarang inilah bagian yang sulit; hanya nilai yang tidak
diketahui, dalam hal ini waktu yang telah berlalu t, yang harus dimasukkan sebagai nol. Jadi,
pastikan untuk mengatur V1, tegangan awal, ke nilai kecil yang sangat mendekati
nol. Jawabannya akan cukup akurat, selama nilai yang sangat kecil dimasukkan untuk
V1. Contoh yang ditunjukkan menggunakan V1 = 0,001 volt.
Singkatnya, dalam contoh ini kita menemukan bahwa dibutuhkan sekitar 0,514 detik untuk
tegangan kapasitor naik dari 0 menjadi 4 volt setelah 5 volt diterapkan pada resistor 47K ohm,
ketika kapasitor 6,8 mikroFarad.
seri
Resistor secara seri dapat diganti dengan resistor tunggal yang dihitung sebagai jumlah
dari resistansi. Berikut rumusnya:
Rumus ini juga berlaku untuk impedansi bilangan kompleks yang dihubungkan secara seri,
dan kode contoh menunjukkan satu set resistor dan satu set impedansi yang dikonversi ke nilai
tunggal yang setara dengan memanggil fungsi series().
def series(zlist):
zs=sum(z for z in zlist)
return zs
print("Series (R or Z)")
print("series(list)")
Program mendefinisikan fungsi series(), kemudian mencetak instruksi pengingat untuk

penggunaannya. Di shell, berikan daftar resistensi dan/atau impedansi ke fungsi
series(). Resistansi total yang dihasilkan, atau impedansi, adalah output sebagai hasilnya.
Misalnya, tiga resistor dirangkai secara seri. Mereka adalah 300, 400, dan 500
ohm. Berapakah hambatan total rangkaian tersebut?
Ini menunjukkan Anda dapat mengganti tiga resistor dengan satu resistor 1200 ohm.
Pastikan untuk meneruskan daftar dua nilai atau lebih ke fungsi series() dengan
menggunakan tanda kurung siku untuk membungkus semua nilai ke dalam argumen daftar
tunggal.
Berikut adalah contoh melewatkan daftar dua impedansi bilangan kompleks. Hasil

penelitian menunjukkan bahwa impedansi 300+400j secara seri dengan 500-600j dapat diganti
dengan impedansi tunggal 800-200j.
zround
Angka floating point dengan Python mudah dibulatkan ke n tempat desimal menggunakan
fungsi round(). Bilangan kompleks, seperti yang kita gunakan untuk nilai impedansi listrik dalam
beberapa program dalam bab ini, tidak begitu mudah dibulatkan. Lihatlah hasil yang ditampilkan
dalam program paralel untuk melihat bagaimana nilai bilangan kompleks yang dihitung
membentang dengan jelas di seluruh tampilan kalkulator, membutuhkan pembulatan mental agar
berguna.
Fungsi zround yang disajikan di sini membulatkan setiap bagian dari bilangan kompleks,
dan mengembalikan hasil yang lebih sederhana. Jika Anda sering bekerja dengan bilangan
kompleks, Anda akan menemukan fungsi ini berguna.
def zround(z,n):
r=round(z.real,n)
i=round(z.imag,n)
return r+i*1j
z=(300+400j)**(1/3)
print(z)
zr=zround(z,3)
print(zr)
Kode contoh pertama menghitung akar pangkat tiga dari bilangan kompleks 300+400j dan
mencetak hasilnya. Seperti yang Anda lihat, hasilnya memiliki banyak tempat desimal dan
kemungkinan tidak terlalu berguna dari sudut pandang teknik elektro. Hasilnya kemudian
dibulatkan menjadi 3 tempat desimal, dan bilangan kompleks yang dicetak jauh lebih mudah
diatur di dunia nyata.
3.
Game dan Peluang
Bab ini memungkinkan Anda menjelajahi beberapa statistik menarik dan tantangan
probabilitas, serta memainkan beberapa permainan yang merangsang.
Pernahkah Anda mendengar tentang teka-teki Monty Hall? Yang ini telah membuat
bingung beberapa pemikir terbaik di dunia, tetapi mudah untuk membuat program Python untuk
menguji jawaban yang benar. Pastikan untuk melihat dari dekat program itu.
Program lain dalam bab ini termasuk membagikan setumpuk kartu, membalik koin jutaan
kali, menghitung nilai pi menggunakan panah dan jarum, dan mengacak kata-kata untuk melihat
apa yang dapat Anda temukan.
deck_of_cards
Program ini membuat setumpuk kartu remi standar, mengocok dek, dan kemudian
membagikan kartu sebanyak yang Anda inginkan. Dek terdiri dari 52 kartu ditambah sejumlah
kartu joker yang diinginkan.
Inti dari program ini adalah dua fungsi yang mungkin ingin Anda gunakan dalam
pembuatan permainan kartu yang lebih rumit. Panggil deck() untuk membuat deck yang diacak,
dan berikan deck ini (daftar Python) ke card() untuk menangani kartu tanpa pengulangan.
Dalam contoh ini sebuah dek dengan dua pelawak dibuat dan dikocok, dan kartu tujuh
tangan dibagikan.
Fungsi randrange() yang diimpor dari modul acak membuat dek yang berbeda setiap kali
program dijalankan.
from random import *
def deck(j):
d=list(range(52+j))
for i in range(52+j):
k=randrange(52+j)
d[i],d[k]=d[k],d[i]
return d
def card(d,n):
c=d[n]
if c>51:
return "Joker"
suit=["Hearts","Clubs","Spades","Diamonds"]
face=["Ace","2","3","4","5","6","7","8",
"9","10","Jack","Queen","King"]
return face[c%13]+" of "+suit[c//13]
j=int(input("How many jokers: "))

d=deck(j)
n=int(input("Deal how many cards: "))

print("")
if n>len(d):
msg="Deck has only {} cards"
print(msg.format(len(d)))
else:
for i in range(n):
print(card(d,i))
dadu
Program ini melempar beberapa dadu bersisi enam, menunjukkan angka pada masing-
masing dadu, jumlah, dan rata-ratanya.
Dalam contoh ini lima dadu dilempar, menunjukkan 5, 1, 3, 3, dan 1 titik di wajah
mereka. Jumlah dadu adalah 13, dan rata-ratanya adalah 2,6.
Fungsi randint(1,6) dari modul acak menyediakan fungsi inti yang digunakan dalam
program ini. Banyak fungsi Python memproses argumen hingga tetapi tidak termasuk nilai kedua
yang diteruskan. Fungsi randint() berbeda karena argumennya inklusif. Dalam hal ini semua nilai
integer dari 1 hingga 6, inklusif, kemungkinan besar akan dikembalikan secara acak.
Tantangan yang menarik adalah memodifikasi program ini untuk melempar dadu standar
untuk Dungeons and Dragons. Anda akan membutuhkan masing-masing satu dadu bersisi 4, 6, 8,
10, 12, dan 20.
n=int(input("How many dice: "))

s=""
t=0
for i in range(n):
d=randint(1,6)
t+=d
s+=str(d)+" "
print(s)
print("Sum: {} Avg: {}".format(t,t/n))
angka
Digits adalah permainan menantang yang bisa sangat menyenangkan, atau bisa membuat
Anda gila! Ini pasti akan meregangkan sel-sel otak Anda saat Anda naik level. Level 1 sangat
mudah, namun saya tidak tahu siapa pun yang telah memecahkan game level 9 saat ini. Mungkin
Anda akan menjadi yang pertama!
Aturannya cukup sederhana. Angka 1 sampai 9 disusun secara acak dalam kotak 3 x 3,

dengan beberapa di antaranya hilang. Digit ini ditampilkan dengan warna biru. Anda perlu
mencari tahu apa angka yang hilang. Di sekitar tepi permainan adalah nomor petunjuk,
ditampilkan dalam warna hijau tua. Mereka terletak di kedua ujung setiap baris dan kolom, dan
mereka adalah hasil dari penambahan atau pengurangan angka pada baris atau kolom yang
diberikan secara diam-diam.
Ketika Anda merasa bahwa Anda telah mengetahui semua angka dengan benar, tekan
[esc] untuk melihat solusinya. Digit yang hilang akan muncul dengan warna merah untuk
verifikasi. Tekan [esc] lagi untuk menghapus puzzle, dan sekali lagi untuk keluar kembali ke
shell.
Mulailah dengan tingkat keahlian 1. Ini akan membuat permainan yang sangat sederhana
yang membantu Anda memahami bagaimana permainan itu dimainkan. Ini dia:
Masukkan 1 untuk memilih level paling sederhana. Berikut ini contoh yang ditampilkan:
Perhatikan bahwa area tengah memiliki semua angka 1 sampai 9, kecuali angka 9. Jelas
bahwa titik yang digarisbawahi adalah tempat angka 9. Ini jelas merupakan level
pemula! Sekarang lihat bagian atas kolom itu. Angka-angka pada kolom tersebut, 7, 1 dan 9,
dapat dijumlahkan dan dikurangkan untuk mendapatkan hasil 17. Jumlahkan ketiga angka
tersebut untuk mendapatkan 17. Angka 6 di ujung kanan baris pertama dapat dihitung sebagai 2 -
5 + 9. Tantangan Anda adalah menemukan lokasi setiap digit dengan menggunakan tanda plus
atau minus secara acak sehingga jawaban di kedua ujung setiap baris dan kolom dapat bekerja
dengan benar. Berikut tampilan solusi untuk game pertama ini.
Oke, itu mudah. Sekarang atur level ke sesuatu seperti 5 ...
Sekarang itulah yang saya bicarakan! Lihatlah kolom tengah, di mana ada 14 di atas dan -2
di bawah. Ada beberapa kemungkinan susunan angka yang hilang sedemikian rupa sehingga
angka atas plus atau minus angka tengah plus atau minus 1 akan sama dengan -2. Sebaliknya,
kita mulai dengan 1 dan menambahkan atau mengurangi angka yang sama untuk mencapai 14.
Berapa lama waktu yang Anda butuhkan untuk menemukan di mana sisa angka harus
ditempatkan?
Jika Anda terjebak, tekan [esc] untuk melihat susunan 9 digit untuk solusi, seperti yang
ditunjukkan di sini...
Saya menyarankan untuk membuat game level 9, menuliskan di atas kertas teka-teki yang
ditampilkan, dan kemudian mengerjakannya terus menerus sepanjang hari. Ini adalah cara yang
baik, seperti bermain Sudoko, untuk menjaga sel-sel otak Anda tetap tertekuk dan berolahraga
dengan cara yang menarik. Dapatkah Anda menemukan solusi lebih cepat dari teman Anda?
def red(): set_color(255,0,0)

def green(): set_color(0,99,0)
def blue(): set_color(0,0,255)
def black(): set_color(0,0,0)
def rsign():
return randint(0,1) * 2 - 1
def add_sub(a,b,c):
return a + rsign() * b + rsign() * c
# Get desired challenge

print("\n\nDIGITS - an add/sub game\n")
print("Place the digits 1 thru 9 in")
print("center. Add or subtract along")
print("each row/col to match results.")
print("\nEnter level 1 to 9...")
print("1 Beginner")
print("9 Ultra Wizard")
w=int(input("? "))
# Create and shuffle the digits

dg=[1,2,3,4,5,6,7,8,9]
for i in range(9):
j=randint(0,8)
dg[i],dg[j]=dg[j],dg[i]

# Create 12 edge values
ans = []
ans.append(add_sub(dg[6],dg[3],dg[0]))
# Create string layout

set_window(0,10,0,10)
# Two states
state=0
while True:
clear()
if state==2:
draw_text(3,5,"Press [esc] to exit")
break

# Top row
green()
for i in range(3):
draw_text(i+4,8,ans[i])
# Three middle rows

k=0
for i in range(3):
green()
draw_text(2,6-i,ans[11-i])
blue()
for j in range(3):
if dg[k] <= 9-w:
draw_text(4+j,6-i,dg[k])
else:
if state==0:
draw_text(4+j,6-i,"_")
else:
red()
draw_text(4+j,6-i,dg[k])
blue()
k+=1
green()
draw_text(8,6-i,ans[3+i])
# Bottom row

green()
for i in range(3):
draw_text(i+4,2,ans[8-i])
# Wait for user

black()
draw_text(3,0,"Press [esc] to continue")
while get_key() != "esc":
pass

state+=1
fact_comb_perm
Program ini menciptakan tiga fungsi yang berguna untuk statistik dan tantangan
probabilitas. Fungsi fact() mengembalikan faktorial bilangan bulat, perm() menghitung jumlah
permutasi dari n hal yang diambil r pada suatu waktu, dan comb() mengembalikan jumlah
kombinasi dari n hal yang diambil r pada suatu waktu.
Untuk program ini saya memutuskan untuk memasukkan nilai n dan r langsung dalam
kode, daripada meminta angka menggunakan input(). Untuk mencoba nilai lain, masuk ke mode
editor dan ubah baris di mana n dan r ditetapkan. Untuk contoh berikut, nilai-nilai ini diatur ke
52 dan 5. Saya menggunakan 52 karena itu adalah jumlah kartu dalam setumpuk kartu remi
standar.
Ada lebih dari satu cara untuk memprogram fungsi faktorial. Banyak sumber
menunjukkan cara menggunakan rekursi, konsep yang efisien dan ringkas yang juga berguna
untuk tugas pemrograman lainnya. Saya memilih untuk menggunakan loop untuk mengalikan
semua angka dari 1 hingga n bersama-sama, karena ini cepat dan tidak memakan banyak memori
seperti yang dapat terjadi dengan rekursi.
Fungsi fact() menunjukkan bagaimana bilangan bulat dalam Python tidak dibatasi
ukurannya, selain batasan yang melekat pada memori mesin atau pertimbangan
kecepatan. Contoh menghitung faktorial 100, mengembalikan hasil numerik yang benar-benar
besar, dan ini adalah sesuatu yang kebanyakan kalkulator dan bahasa pemrograman lain tidak
akan membiarkan Anda melakukannya. Python luar biasa!
def fact(n):
if n<0:
return 0
if n<2:
return 1
fact=1
for i in range(n):
fact*=(i+1)
return fact
def perm(n,r):
return fact(n)//fact(n-r)
def comb(n,r):
return perm(n,r)//fact(r)

print("fact(5): ",fact(5))
n,r=52,5
print("n={}, r={}".format(n,r))
print("perm(n,r): ",perm(n,r))
print("comb(n,r): ",comb(n,r))
heads_in_a_row
Rata-rata, berapa kali Anda perlu melempar koin untuk mendapatkan tujuh kepala
berturut-turut? Hal ini dapat diselesaikan dengan rumus matematika eksplisit, seperti yang
ditunjukkan pada baris terakhir program ini, tetapi akan jauh lebih menyenangkan jika kalkulator
Anda mensimulasikan sejumlah lompatan berturut-turut untuk mendapatkan jawaban
perkiraan. Semakin banyak percobaan yang Anda lakukan, atau semakin sering Anda melempar
koin, semakin akurat jawabannya, rata-rata tentu saja. Ini adalah contoh yang baik dari simulasi
Monte Carlo, di mana banyak percobaan acak dapat dijalankan di komputer untuk semakin dekat
dengan jawaban dunia nyata yang akurat.
Dalam hal ini, diprediksi secara matematis bahwa dibutuhkan rata-rata 254 pelemparan
koin berturut-turut untuk mendapatkan tujuh kepala berturut-turut. Beberapa kali lebih sedikit,
beberapa kali lebih banyak, tetapi rata-rata menghasilkan 254 flips.
Program ini menggunakan modul acak untuk menghasilkan lemparan koin secara acak,
menghitung setiap kali kepala muncul, mengatur ulang hitungan ketika ekor muncul, dan
menghentikan setiap percobaan ketika tujuh kepala berturut-turut akhirnya muncul. Seperti yang
ditunjukkan, setelah 200 percobaan, dibutuhkan rata-rata 242,48 lemparan untuk mendapatkan
tujuh kepala berturut-turut. Jalankan program ini beberapa kali untuk melihat pergeseran rata-
rata ini ke nilai di sekitar 254.
Jangan ragu untuk bereksperimen dengan mengubah jumlah percobaan, atau jumlah target
kepala berturut-turut. Namun berhati-hatilah, karena program dapat memakan waktu lama untuk
dijalankan jika jumlah yang lebih besar digunakan.
goal=7
trials=200
tally=0
def flips():
n=0
inarow=0
while 1:
n+=1
if randint(0,1):
inarow+=1
else:
inarow=0
if inarow==goal:
return n

for i in range(trials):
tally+=flips()
print("\nFlips to get",goal,"heads in a row")

print("Trials: ",trials)
print("Average: ",tally/trials)
print("Predicted: ",2**(goal+1)-2)
berburu_arah
Dibandingkan dengan hunting_distance (lihat program berikutnya), game ini persis sama,
hanya berbeda (salah satu ucapan favorit saya.) Tujuan Anda adalah menemukan koordinat
target yang ditetapkan secara acak dalam kisi 100 x 100. Dengan setiap tebakan, Anda diarahkan
ke target menggunakan arah seperti peta, seperti "Pindah SE" untuk tenggara, atau "Pindahkan
W" untuk lurus ke barat. Tujuannya adalah untuk menemukan target dalam gerakan sesedikit
mungkin.
Berikut adalah contoh menjalankan permainan. Dalam hal ini saya menghapus komentar
pada baris print(x,y) sehingga Anda dapat melihat bahwa targetnya adalah 57,32. Koordinat
menggunakan sudut kiri bawah sebagai titik asal, atau titik x,y dari (0,0).
x=randrange(100)
y=randrange(100)
# print(x,y)
n=0
while 1:
n+=1
g=input("x,y? ").split(",")
a=int(g[0])
b=int(g[1])
d=""
if b<y:d+="N"
if b>y:d+="S"
if a<x:d+="E"
if a>x:d+="W"
if d=="":break
print("Move",d)
print("\nBingo! at {} guesses".format(n))
berburu_jarak
Program ini adalah permainan yang menantang keterampilan visual-spasial Anda, serta
proses berpikir numerik dan analitik Anda. Selain itu, ini menyenangkan!
Di suatu tempat dalam kisi 100 x 100 ada makhluk/target/tujuan untuk Anda
temukan. Anda memasukkan pasangan koordinat, dan jarak garis lurus ke titik tersembunyi
dihitung dan ditampilkan. Tujuannya adalah untuk menemukan makhluk/target/tujuan dalam
tebakan sesedikit mungkin.
Anda mungkin ingin mendapatkan selembar kertas grafik dan lingkaran sketsa yang
dipusatkan pada titik tebakan Anda. Ini akan memungkinkan Anda untuk menemukan target
hanya dalam beberapa tebakan, dan itu tidak curang selama Anda bersenang-senang dan
mempelajari sesuatu tentang teorema pythagoras dan keterampilan geometri analitik
lainnya. Atau, seperti saya, Anda bisa menebak tebakan Anda, mencoba memperpendek jarak
dengan setiap tebakan, dan membalikkan arah saat semakin jauh. Itu juga menyenangkan.
Berikut adalah contoh singkat dari permainan (biasanya dapat membutuhkan lebih dari 3
tebakan), tetapi ini menunjukkan cara kerjanya:
Perhatikan dalam kode sumber ada baris komentar, di mana ia mencetak nilai target x dan
y. Jangan ragu untuk menghapus komentar pada baris ini untuk membuat permainan lebih
mudah. Anda akan melihat koordinat makhluk/target/tujuan dan Anda dapat bermain-main
dengan tebakan untuk melihat bagaimana jarak bekerja dengan setiap tebakan.
x=randrange(100)
y=randrange(100)
# print(x,y)
n=0
while 1:
n+=1
g=input("x,y? ").split(",")
a=int(g[0])
b=int(g[1])
d=((x-a)**2+(y-b)**2)**.5
if d==0:break
print("Dist: ",d)
print("\nBingo! at {} guesses".format(n))
campur aduk
Program ini meminta kata atau frasa, lalu mengacak huruf secara acak sebanyak yang
Anda inginkan. Ini berguna untuk berbagai teka-teki atau tantangan anagram atau kata campur
aduk.
Misalnya, saya memasukkan nama depan dan belakang saya, semuanya terdiri dari
sembilan huruf, dan meminta 5 acak acak untuk ditampilkan:
Saya sudah mulai melihat beberapa kata pendek, seperti OR, AIR, HOG, HAIR, dan
sebagainya. Saya terus meminta lebih banyak campur aduk, dan beberapa kata yang lebih besar
mulai muncul di benak saya ketika saya menatap hasilnya, kata-kata seperti CHAGRIN, CIGAR,
JARGON, JOIN, dan GAIN.
Anda dapat terus mengacak sebanyak yang Anda inginkan, dan program akan berakhir
ketika Anda hanya menekan OK tanpa memasukkan hitungan.
print("Jumble word or phrase?")

s=input("? ")
s=list(s.replace(" ","").upper())
m=len(s)
while 1:
try:
n=int(input("How many jumbles? "))
except:
break
while n:
n-=1
for i in range(m):
j=randrange(m)
s[i],s[j]=s[j],s[i]
t=""
for i in range(m):
t+=s[i]
print(t)
labirin
Program ini menggunakan modul grafis ti_draw untuk membuat sketsa labirin acak pada
kalkulator Anda. Setiap kali Anda menjalankan program, labirin yang berbeda digambar, jadi ini
adalah tantangan baru setiap saat. Modul acak memberikan keacakan.
Seni dan ilmu menciptakan labirin sangat menarik. Periksa internet jika subjek ini menarik
bagi Anda. Atau, Anda bisa bersenang-senang dengan menjalankan program ini untuk melihat
seberapa cepat Anda dapat menavigasi mental dari sudut kiri atas ke kanan bawah untuk
membantu menjaga sel-sel otak Anda dalam kondisi yang baik.
def vline(x,y,w):
if w:
x1=x*wl+9
y1=y*wl+3
draw_line(x1,y1,x1,y1+wl)
def hline(x,y,w):
if w:
x1=x*wl+9
y1=y*wl+3
draw_line(x1,y1,x1+wl,y1)
def cell(x,y):
z=a[x+y*w]
hline(x,y,z&1)
vline(x+1,y,z&2)
hline(x,y+1,z&4)
vline(x,y,z&8)
def disp():
clear()
for x in range(w):
for y in range(h):
cell(x,y)
def nor(u):
v=u-w
if v>0:
if a[v]==15:
a[u]&=14
a[v]&=11
return v
return u
def eas(u):
v=u+1
if v%w:
if a[v]==15:
a[u]&=13
a[v]&=7
return v
return u
def sou(u):
v=u+w
if v<n:
if a[v]==15:
a[u]&=11
a[v]&=14
return v
return u
def wes(u):
v=u-1
if u%w:
if a[v]==15:
a[u]&=7
a[v]&=13
return v
return u
def move(u):
for i in range(c):
d=randrange(4)
if d==0:
u=nor(u)
if d==1:
u=eas(u)
if d==2:
u=sou(u)
if d==3:
u=wes(u)
# Initialize
w=25
h=17
n=w*h
c=n/4
wl=12
a=[15 for x in range(n)]
t=[x for x in range(n)]
a[0]=7
clear()
draw_text(125,110,"-thinking-")
while 1:
# Shuffle the indexes

for i in range(n):
j=randrange(n)
t[i],t[j]=t[j],t[i]
# Check each cell in index order

done=True
for i in range(n):
u=t[i]
if a[u]==15:
done=False
else:
move(u)

# Done if all cells connected
if done:
break
# Done
a[n-1]&=13
disp()
Penyimpanan
Game ini menantang kemampuan memori jangka pendek Anda. Jika Anda memainkannya
cukup, itu mungkin membantu Anda dalam jangka panjang. Jangan lupa itu! Atau jika ya,
mungkin Anda harus lebih sering memainkan game ini. Maaf, saya terkadang terbawa suasana.
Bagaimanapun, cara kerjanya adalah bahwa bilangan bulat pendek ditampilkan sampai
Anda siap untuk melanjutkan. Tekan [enter] dan nomornya akan hilang. Anda diminta untuk
mengetikkan nomor dari memori, dan jika benar Anda mendapatkan nomor yang lebih
panjang. Jika Anda tidak memasukkan angka dengan benar, angka yang lebih pendek akan
muncul untuk tebakan berikutnya. Setelah selusin nomor tantangan, skor total Anda muncul,
seperti yang dihitung dari panjang total semua angka.
Berikut adalah contoh permainan yang sedang berlangsung. Perhatikan bahwa Anda perlu
menekan [enter] untuk menghapus layar sebelum mengingat dan memasukkan nomor yang baru
saja Anda lihat.
def digs(n):
x=randint(1,9)
for i in range(n-1):
x=x*10+randrange(10)
return x
def blank_lines(n):
for i in range(n):
print(' ')
n=0
s=3
t=0
blank_lines(3)
print("Repeat after me...")
blank_lines(6)
for i in range(10):
n+=1
t+=s
x=digs(s)
print(' ')
print(x)
print("[enter] to proceed...")
while get_key() != "enter":
pass
blank_lines(18)
print("What number do you remember?")
try:
g=int(input())
except:
g=0
break
if g==x:
print("Yes!")
s+=1
else:
print("Sorry")
s-=1
msg=" guesses until final score"
print(str(10-n),msg)
blank_lines(5)
if g:
print("\n\nFinal Score: ",t)
monty_hall
Pernahkah Anda mendengar teka-teki Monty Hall yang terkenal? Ini sangat bodoh, dan itu
membingungkan beberapa pikiran top ketika pertama kali dibahas.
Jadi, Monty menunjukkan tiga pintu, dan menyatakan ada mobil di belakang salah
satunya. Anda menebak salah satu pintu. Sebelum membuka pintu Anda untuk melihat apakah
Anda menang, Monty membuka salah satu dari dua pintu lainnya, di mana tidak ada apa pun di
balik pintu itu. Lalu dia bertanya apakah Anda ingin beralih dengan pintu terakhir sebelum
pengungkapan besar. Haruskah Anda beralih? Apakah itu akan membuat perbedaan?
Banyak orang mengatakan bahwa karena ada dua pintu yang belum dibuka, ada
kemungkinan lima puluh lima puluh mobil berada di belakang salah satunya. Jadi tidak masalah
jika Anda beralih sebelum Monty membuka pintu Anda. Tapi ternyata itu salah!
Program ini melakukan simulasi Monte Carlo (Monte ini tidak terkait dengan Monty lain,
atau Monty Penuh dalam hal ini, tapi itu cerita lain.) Program mensimulasikan Anda diminta
1000 kali oleh Monty jika Anda ingin beralih, dan itu menghitung berapa kali Anda
memenangkan mobil jika Anda beralih dan jika Anda tidak beralih.
Jika Anda beralih, peluang Anda untuk menang adalah 2 kali dari 3, dan jika Anda tidak
beralih, peluang Anda adalah 1 dari 3. Singkatnya, peluangnya menguntungkan Anda, jika Anda
beralih!
Jika hasil ini membingungkan Anda, bacalah di Internet tentang "Masalah Monty Hall",
atau tonton salah satu dari beberapa video Youtube yang membahas topik tersebut. Sementara
itu, bersenang-senanglah mensimulasikan banyak kemenangan dengan kalkulator teknologi TI-
Nspire™ CX II Anda!
games=1000
for n in range(2):
if n:
switch=True
else:
switch=False
wins=0
for i in range(games):
doors=[False,False,False]
doors[randrange(3)]=True
choice1=randrange(3)
monty_opens=randrange(3)
while monty_opens==choice1:
monty_opens=randrange(3)
if switch==False:
if doors[choice1]==True:
wins+=1
else:
if doors[choice1]==False:
wins+=1
if switch:
s="does"
else:
s="does not"
print(" ")
print("Win percent when contestant")
print("{} swap last 2 doors:".format(s))
print(round(100*wins/games,2))
pi_buffon
Nilai pi dapat dihitung dengan banyak cara, termasuk mensimulasikan keacakan dunia
nyata dengan angka acak. Seorang pria bernama Georges-Louis de Buffon datang dengan
metode keren di sepanjang garis ini, jauh di abad ke-18, jauh sebelum kalkulator Texas
Instruments pertama dipikirkan. Dia menyarankan menjatuhkan jarum secara acak di lantai yang
ditandai dengan garis paralel dengan jarak tetap, dan menghitung jumlah jarum yang menyentuh
salah satu garis ketika berhenti dibandingkan dengan jumlah total yang dijatuhkan.
Ada banyak tempat di Internet di mana Anda dapat membaca semua matematika yang
terlibat dalam proses ini, semuanya mengarah pada perkiraan nilai pi. Ini benar-benar
cerdik. Dengan kalkulator teknologi TI-Nspire™ CX II Anda, Anda dapat mensimulasikan
menjatuhkan ribuan jarum hanya dalam hitungan detik, fitur yang bagus karena metode ini
sangat lambat untuk berkumpul secara akurat pada nilai pi. Anda harus memiliki banyak
kesabaran untuk menggunakan jarum asli!
Program menanyakan berapa banyak jarum yang ingin Anda jatuhkan. Coba 1.000 atau
mungkin 10.000 jarum untuk waktu berjalan yang wajar. Coba lebih banyak jika Anda dapat
membiarkan kalkulator Anda duduk di rak dan berjalan untuk waktu yang lama, atau kurang jika
Anda hanya ingin melihat beberapa perkiraan kasar dari pi. Berikut hasil pemilihan 1.000 jarum:
from math import *
needles=1000
hits=0
p2=pi*2
for i in range(needles):
x=random()
a=uniform(0,p2)
x2=x+cos(a)
if x2<0 or x2>1:
hits+=1
print(2.0*needles/hits)
Program serupa untuk menghitung pi menggunakan angka acak adalah pi_darts dan
pi_graphics.
pi_darts
Bayangkan sebuah papan dart khusus berbentuk persegi dengan lingkaran di dalamnya
yang hanya menyentuh tepi persegi.
Jika Anda melempar dart ke papan dart ini sepenuhnya secara acak, sehingga setiap inci
persegi memiliki peluang yang sama untuk dipukul seperti inci persegi lainnya, maka rasio
jumlah pukulan dalam lingkaran dengan jumlah total lemparan dapat memberikan perkiraan dari
nilai pi. Ini mudah dilihat karena rasionya bergantung pada luas lingkaran dan persegi, dan luas
lingkaran dihitung menggunakan nilai pi.
Untuk menyederhanakan program, kita dapat menggunakan sudut kanan atas diagram di
atas, luas total hanya lingkaran dan persegi penuh. Ini menyederhanakan matematika,
memungkinkan angka acak antara 0 dan 1 dihasilkan secara efisien, dan membuatnya lebih
mudah untuk memeriksa jarak dari pusat lingkaran di sudut kiri bawah juga.
Program ini adalah contoh lain dari simulasi Monte Carlo, di mana banyak percobaan acak
memberikan perkiraan nilai. Program berulang selamanya, atau sampai Anda menekan [esc],
mana saja yang lebih dulu. Setelah setiap 1000 anak panah dihitung, tampilan diperbarui dengan
nilai perkiraan pi.
Sama seperti jarum Buffon, ini bukan cara yang sangat efisien untuk menghitung atau
memperkirakan nilai pi, ini hanya informatif dan menyenangkan untuk melihat cara kerjanya.
def red(): set_color(255, 0, 0)

def green(): set_color(0, 99, 0)
def blue(): set_color(0, 0, 255)
def black(): set_color(0, 0, 0)
def white(): set_color(255,255,255)
set_window(-.4, 1.4, -.095, 1.05)

hits=0
darts=0
while get_key()!='esc':
x=random()
y=random()
darts+=1
if x*x+y*y<1:
hits+=1
red()
else:
blue()
plot_xy(x,y,7)
if darts%1000==0:
white()
fill_rect(-.4,-.1,1.8,.08)
s="Darts: {} Pi: {}".format(darts,4*hits/darts)
black()
draw_text(-.1,-.1,s)
Perhatikan bahwa beberapa fungsi satu baris didefinisikan dalam program untuk mengatur
berbagai warna yang digunakan untuk menunjukkan hit, misses, dan detail lainnya. Ini adalah
salah satu cara yang baik untuk membuat program grafis Anda sendiri lebih mudah dibaca dan
dipelihara.
random_bytes
Modul acak menyediakan beberapa jenis nomor pseudorandom. Program ini memanggil

fungsi getrandbits(8) untuk menghasilkan bilangan bulat acak yang berisi 8 bit. Dengan kata lain,
memanggil fungsi ini dengan cara ini mengembalikan byte acak.
Program singkat ini hanya menambahkan semua byte acak dan membaginya dengan
jumlah byte. Rata-rata harus sekitar 127,5. Anda mungkin pada awalnya berpikir rata-rata
seharusnya 128, karena satu byte dapat menampung 256 nilai unik dalam 8 bit. Itu benar, tetapi
nilai tersebut berjalan dari 0 saat tidak ada bit yang disetel, hingga 255 saat semua bit disetel ke
1. Rata-rata dari nilai ini adalah 127,5.
Rata-rata aktual yang dihitung dari 10.000 byte tidak akan persis 127,5, tetapi jika Anda
menjalankan program ini beberapa kali, Anda akan melihat rata-rata semacam itu menjadi sekitar
127,5. Lebih atau kurang.
n=10000
x=0
print("working...")
for i in range(n):
x+=getrandbits(8)
print(n,x/n)
kata_perm
Program ini memproses huruf dalam kata hingga 5 karakter, dan menampilkan semua
kemungkinan permutasi, atau penataan ulang tanpa pengulangan. Misalnya, nama depan saya,
JOHN, dapat disusun menjadi 24 kombinasi yang berbeda.
Nama belakang saya, CRAIG, memiliki lima karakter, dan permutasi huruf-hurufnya
menghasilkan 120 urutan unik. Seperti yang Anda lihat, jumlah permutasi meningkat dengan
cepat seiring dengan bertambahnya panjang kata. Untuk N karakter, jumlah permutasinya adalah
N! (faktorial). Kata enam karakter akan memiliki 720 kombinasi, jadi saya membatasi program
hanya untuk kata lima karakter. Anda dapat mengubah kode untuk mengizinkan lebih dari 5 jika
Anda mau, bersiaplah untuk banyak keluaran, dan banyak gulir untuk melihat semua hasilnya!
def perm(s):
if len(s)==1:
return [s]
b=[]
for i in range(len(s)):
m=s[i]
c=s[:i]+s[i+1:]
for j in perm(c):
b.append(m+j)
return b
while 1:
s=input("Word? ")
if len(s)>5:
print("5 chars max\n")
else:
break
p=perm(s.upper())
u=""
for t in p:
u+=" "+t
if len(u)>25:
print(u)
u=""
print(u)
Program berulang untuk meminta kata berikutnya sebanyak yang Anda inginkan, sampai
Anda cukup menekan [enter] pada prompt. Perhatikan bahwa loop ini menggunakan "sementara
1:" alih-alih "sementara True:". Keduanya bekerja sama, tetapi angka 1 lebih pendek dalam
daftar kode daripada nilai True. Python menguji apa pun yang Anda masukkan setelah
"sementara" untuk "kebenaran", dan angka 1 lulus tes ini.
4.
GPS dan Navigasi
Lintang dan Bujur sangat menyenangkan, terutama ketika persentase tinggi orang
sekarang memiliki ponsel cerdas dengan chip GPS yang memberi tahu mereka dengan tepat di
mana mereka berada setiap saat. Selain itu, peta Google (dan lainnya) menyediakan cara yang
bagus untuk menentukan lokasi titik mana pun di Bumi yang Anda perbesar.
Bab ini memungkinkan Anda menggunakan koordinat tersebut di permukaan bumi untuk
menghitung jarak, arah, dan bahkan luas daratan yang ditentukan oleh tiga koordinat atau lebih.
Perhitungan ini tidak sesederhana jarak, arah, dan luas yang diberikan koordinat kartesius
pada bidang x,y. Ini karena Bumi berbentuk bola, menyebabkan garis bujur "dirapatkan"
semakin dekat dengan kutub utara atau selatan. Tetapi kalkulator teknologi TI-Nspire™ CX II
Anda sangat mampu mengerjakan semua matematika untuk menyelesaikan pekerjaan. Python
membuatnya mudah.
gps_area
Menemukan area di permukaan bumi yang diberikan beberapa koordinat lintang dan bujur
di sudut-sudut area lebih rumit dari yang Anda kira. Program ini sangat menyederhanakan
proses.
Komplikasi pertama terjadi ketika menemukan jarak antara dua koordinat GPS. Jarak
antara garis bujur, yaitu seberapa jauh timur atau barat suatu titik dari titik lain, bervariasi
tergantung pada garis lintang. Ini dijelaskan lebih rinci dalam program gps_distance.
Program ini "berjalan di sekitar" poligon, menghubungkan koordinat pertama dalam daftar
secara berurutan dengan koordinat di sekitar tepi poligon untuk membentuk segitiga
kecil. Jumlah luas segitiga-segitiga ini adalah luas seluruh gambar yang ditentukan oleh daftar
koordinat. Di sini kita akan menggunakan jarak dan sudut arah antara dua koordinat untuk
menghitung luas dari berbagai daerah segitiga di poligon.
Program segitiga di bagian lain buku ini menunjukkan bagaimana menemukan semua
bagian dari sebuah segitiga, termasuk luasnya, jika diberikan kombinasi dari tiga sisi dan
sudutnya. Fungsi sisi-sudut-sisi dipinjam dari program itu untuk mencari luas segitiga-segitiga
kecil.
Hal yang sangat keren adalah meskipun bentuk poligon yang ditentukan oleh koordinat
memiliki cekungan, program secara otomatis menambah dan mengurangi area dengan benar. Ini
bekerja karena sudut antara pasangan titik yang dipilih dan titik pertama biasanya positif selama
"berjalan-jalan". Tetapi dengan kecekungan, satu atau lebih sudutnya negatif, dan luas segitiga
kecil kemudian dihitung sebagai negatif. Semuanya berhasil, di mana area yang tumpang tindih
menambah dan mengurangi dengan benar dan otomatis untuk mendapatkan total area yang
akurat.
Pertama, mari kita lihat contoh yang cukup sederhana. Gedung Pentagon di Arlington,
Virginia memiliki lima sisi, dan lima koordinat GPS di sudut-sudutnya. Google Maps
memungkinkan kita menemukan garis lintang dan garis bujur dari setiap titik pada peta (klik
kanan pada suatu titik dan pilih Apa yang ada di sini? dari menu popup.) Berikut adalah
koordinat sudut yang saya temukan, dalam notasi garis lintang dan garis bujur standar:
38.868868, -77.055655
38.870619, -77.053325
38.872875, -77.054717
38.872532, -77.057948
38.870039, -77.058504
Program pertama-tama mencari luas segitiga 0,1,2 di mana titik 0 adalah koordinat
pertama dalam daftar:
Pentagon "berjalan-jalan" selanjutnya menemukan luas segitiga 0,2,3, seperti yang
ditunjukkan di sini:
Akhirnya, luas segitiga 0,3,4 ditemukan dan ditambahkan ke area lain untuk menemukan
total luas segi lima Pentagon:
Program diatur sedemikian rupa sehingga Anda mengedit daftar poin dalam fungsi
gps_points() untuk menentukan area yang dimaksud. Anda dapat mengulang kode ini untuk
meminta pasangan angka lintang dan bujur pada saat dijalankan, tetapi saya lebih suka
mengeditnya di tempat, terutama dengan daftar koordinat yang lebih panjang. Lebih mudah
untuk memeriksanya, membuat perubahan, dan kemudian menjalankan kembali program. Seperti
yang ditunjukkan dalam daftar program, saya telah mengedit koordinat Pentagon ke dalam
fungsi gps_points().
Jalankan program dan hasilnya adalah sekitar 0,135 kilometer persegi, atau 0,0522 mil
persegi. Sebuah konversi cepat menunjukkan ini menjadi sekitar 33 -" hektar. Saya memeriksa di
Internet dan menemukan beberapa perkiraan ukuran Pentagon, semuanya cukup sesuai dengan
nilai ini.
from math import *
def gps_points():
pts=[]
pts.append([38.868868, -77.055655]) #0
pts.append([38.870619, -77.053325]) #1
pts.append([38.872875, -77.054717]) #2
pts.append([38.872532, -77.057948]) #3
pts.append([38.870039, -77.058504]) #4
return pts
def area_gps(pts):
area=0
if len(pts)>2:
n=2
while n<len(pts):
x0,y0=pts[0]
x1,y1=pts[n-1]
x2,y2=pts[n]
b1,a=nav(x0,y0,x1,y1)
b2,b=nav(x0,y0,x2,y2)
b1=b1 if b1>0 else b1+360
b2=b2 if b2>0 else b2+360
C=b1-b2
area+=area_sas(b,C,a)
n+=1
return area
def nav(la1,lo1,la2,lo2):
la1=radians(la1)
lo1=radians(lo1)
la2=radians(la2)
lo2=radians(lo2)
r=6371
t1=sin(la1)*sin(la2)
t2=cos(la1)*cos(la2)*cos(lo2-lo1)
km=acos(t1+t2)*r
y=sin(lo2-lo1)*cos(la2)
t1=cos(la1)*sin(la2)
t2=sin(la1)*cos(la2)*cos(lo2-lo1)
x=t1-t2
b=degrees(atan2(y,x))
return [b,km]
def area_sas(a,C,b):
return a*b*sin(radians(C))/2
pts=gps_points()
kmsq=round(area_gps(pts),6)
print("Area")
print("km^2: ",kmsq)
misq=round(kmsq*.386102,6)
print("miles^2: ",misq)
Danau Pirus
Contoh kedua menghitung luas permukaan, secara kasar, Danau Turquoise, dekat
Leadville, Colorado. Berikut adalah sketsa singkat (milik Google Maps) dari area yang akan kita
temukan, seperti yang didefinisikan oleh empat titik yang saya pilih di peta:
Empat koordinat peta, mulai dari titik bawah dan bekerja berlawanan arah jarum jam,
adalah:
39.249968, -106.370986
39.273513, -106.348860
39.277695, -106.438465
39.264220, -106.373614
Inilah fungsi gps_points() setelah mengedit koordinat ini ke tempatnya.

def gps_points():
pts=[]
pts.append([39.249968, -106.370986]) #0
pts.append([39.273513, -106.348860]) #1
pts.append([39.277695, -106.438465]) #2
pts.append([39.264220, -106.373614]) #3
return pts
Saya memilih danau ini, dan bentuk ini, dengan sengaja, karena ada cekungan di kiri
bawah, di koordinat terakhir, berlabel 3:
Luas segitiga pertama ditemukan pada 0,1,2 seperti yang ditunjukkan di sini:
Perhatikan bahwa segitiga ini terlalu besar, mencakup lebih banyak area daripada garis
besar danau secara keseluruhan. Tidak apa-apa, karena segitiga berikutnya, pada 0,2,3 adalah
"mundur", dalam urutan titik-titiknya searah jarum jam bukan berlawanan arah jarum jam,
menghasilkan area negatif.
Tidak peduli betapa rumitnya daftar koordinat, selama mereka berada dalam urutan
"berjalan-jalan" yang benar untuk seluruh poligon, semua area dijumlahkan dengan benar, baik
positif maupun negatif, tidak peduli seberapa tumpang tindihnya.
6.289 kilometer persegi adalah sekitar 1.554 hektar. Sebuah cek cepat di Internet
menunjukkan area Danau Turquoise menjadi 1.780 hektar. Mempertimbangkan betapa kasarnya
garis besar danau kami, dengan hanya empat poin untuk mendefinisikannya, perhitungan kami
cukup bagus!
Program ini bekerja dengan baik untuk lahan yang tidak terlalu luas. Bumi tidak datar, jadi
lekukan permukaan bumi mempengaruhi area yang dihitung jika sangat besar, katakanlah ratusan
kilometer di tepi.
gps_distance
Jarak antara dua titik dalam bidang ditemukan menggunakan Teorema Pythagoras, tetapi
jarak di permukaan bola, seperti Bumi, lebih rumit. Program ini secara akurat menghitung jarak
antara dua lokasi berdasarkan koordinat garis lintang dan garis bujurnya, juga disebut sebagai
koordinat GPS.
Algoritme menggunakan beberapa fungsi trigonometri, sehingga modul matematika

diimpor di bagian atas daftar. Fungsi sin() dan cos() di Python menganggap semua sudut dalam
radian, jadi fungsi radian() dalam modul matematika digunakan untuk mengubah garis lintang
dan garis bujur dari derajat standar ke radian. (Ya, ada fungsi derajat() juga, tetapi tidak
digunakan dalam program ini.)
Fungsi distance() adalah inti dari program ini. Inputnya adalah garis lintang dan garis
bujur untuk dua titik di Bumi, dan outputnya adalah kilometer antara dua titik
tersebut. Konstanta 6371 adalah jari-jari Bumi dalam kilometer.
Misalnya, Gateway Arch di St. Louis terlihat di Google Maps, dan kita dapat memperbesar
dan mengklik dengan hati-hati untuk menemukan koordinat di sudut belakang Arch di mana
logam bertemu dengan beton. Itu adalah pasangan koordinat dalam daftar program. Koordinat
lainnya ada di Jembatan Golden Gate di San Francisco, jadi kita bisa mengukur jarak yang lebih
jauh juga.
St Louis Arch secara resmi setinggi 630 kaki dan lebar 630 kaki. Program ini menghitung
lebar 629,9 kaki, yang merupakan hasil yang sangat bagus! Jarak udara (garis lurus) antara San
Francisco dan St. Louis terdaftar sebagai 1745 km, dan program ini menemukan jarak antara
Arch dan Jembatan sebagai 1744,7 mil, yang juga merupakan hasil yang sangat mirip:
from math import *
def distance(pt1,pt2):
la1=radians(pt1[0])
lo1=radians(pt1[1])
la2=radians(pt2[0])
lo2=radians(pt2[1])
r=6371
km=acos(t1+t2)*r
return km
#Arch width
pt1=(38.625412,-90.184555)
pt2=(38.623767,-90.185227)
km=distance(pt1,pt2)
print("Arch Meters: ",km*1000)
print("Arch Feet: ",km*3280.84)
#Arch to Golden Gate Bridge

pt2=(37.820142,-122.478709)
km=distance(pt1,pt2)
print("Arch-Bridge km: ",km)
print("Arch-Bridge miles: ",km*.621371)
titik tengah
Program ini menemukan garis lintang dan garis bujur pada suatu titik di tengah-tengah
antara dua lokasi lain di Bumi. Panggil teman Anda satu atau dua negara bagian dan minta
mereka menemui Anda di titik tengah yang tepat, hanya untuk bersenang-senang.
Program ini juga bagus untuk memeriksa apakah Bumi itu datar atau bulat. Dengan
serius. Pertimbangkan bahwa sudut elevasi Matahari dapat dengan mudah diukur dengan tongkat
meteran sederhana pada hari yang cerah. Saya tidak akan membahas semua detailnya di sini,
tetapi perhatikan bahwa sudut elevasi Matahari yang diukur dari tiga titik yang berjarak sama di
Bumi, akan memberikan semua informasi yang Anda butuhkan. Jika Bumi datar, sudut elevasi
akan berperilaku satu arah, dan jika Bumi bulat, sudut akan berperilaku lain. (Petunjuk: itu
bulat.)
Mari kita cari garis lintang dan bujur dari titik di tengah antara Jembatan Golden Gate di
San Francisco, dan Gateway Arch di St. Louis.
Berikut lokasi salah satu sudut lengkungan, seperti yang kita gunakan dalam program
gps_distance:
la1=38.625412
lo1=-90.184555
Dan inilah koordinat Jembatan Golden Gate dari program yang sama:
la2=37.820142
lo2=-122.478709
Mari masukkan koordinat tersebut ke dalam program, temukan titik tengah di Bumi, lalu
cari titik tersebut di Google Maps untuk melihat apa yang ada di sana:
Titik tengahnya berada di tempat yang sangat indah di sepanjang West Tennessee Creek,
hanya sedikit di barat laut Leadville, Colorado. Itu akan menjadi tempat yang menyenangkan
untuk bertemu temanmu!
from math import *
def mid(pt1,pt2):
la1=radians(pt1[0])
lo1=radians(pt1[1])
la2=radians(pt2[0])
lo2=radians(pt2[1])
x=cos(la1)*cos(lo1)
y=cos(la1)*sin(lo1)
z=sin(la1)
x+=cos(la2)*cos(lo2)
y+=cos(la2)*sin(lo2)
z+=sin(la2)
la=degrees(atan2(z,(x*x+y*y)**.5))
lo=degrees(atan2(y,x))
return [la,lo]
pt1=(38.625412,-90.184555)
pt2=(37.820142,-122.478709)
pt3=mid(pt1,pt2)
print("Point1, Point2, Midpoint")
print(pt1)
print(pt2)
print(pt3)
Perhatikan bahwa koordinat lokasi diedit langsung ke dalam daftar program, di mana
penugasan dibuat ke variabel pt1 dan pt2.
navigasikan
Program ini menghitung jarak dan bantalan antara dua titik di permukaan bumi.
Sangat mudah untuk menemukan lokasi suatu titik di Bumi menggunakan Google
Maps. Zoom in ke lokasi, klik kanan pada titik, dan pilih "What's Here?" dari menu pop-up. Itu
cara yang baik untuk mendapatkan angka lintang dan bujur yang diperlukan sebagai masukan
untuk program ini.
Rumus rute lingkaran besar yang digunakan di sini akurat untuk jarak pendek, seperti
mengukur bentangan pendek trotoar di depan sekolah, dan juga akurat untuk jarak jauh di mana
bentuk bola Bumi menjadi sangat penting.
Lokasi, atau koordinat GPS yang diambil dari Google Maps, dari Dulce, NM dan Taos,
NM dikodekan ke dalam program untuk mengujinya. Jangan ragu untuk mengubah angka-angka
ini, atau mengubah program agar meminta input. Fungsionalitas inti ada di fungsi nav() , jadi
panggil saja sesuka Anda.
Seperti yang ditunjukkan, jarak dari Dulce ke Taos sangat dekat dengan 140 km, dan arah
ke kepala adalah 114,3 derajat, atau hanya sedikit ke selatan dari timur.
from math import *
def nav(pt1,pt2):
la1=radians(pt1[0])
lo1=radians(pt1[1])
la2=radians(pt2[0])
lo2=radians(pt2[1])
r=6371
km=acos(t1+t2)*r
t1=cos(la1)*sin(la2)
t2=sin(la1)*cos(la2)*cos(lo2-lo1)
x=t1-t2
y=sin(lo2-lo1)*cos(la2)
b=degrees(atan2(y,x))
return [b,km]
# Dulce, NM
pt1=(36.9336,-106.9989)
# Taos, NM
pt2=(36.4072,-105.5731)
# Distance and bearing

b,km=nav(pt1,pt2)
print("pt1: ",pt1)
print("pt2: ",pt2)
print("km: ",km)
print("miles: ",km*.621371)
print("bearing: ",b)
5.
Uang dan Keuangan
Bab ini menyajikan beberapa program untuk menghitung bunga, tabungan, pinjaman dan
rincian lainnya yang berkaitan dengan aliran uang.
Lain kali Anda siap untuk membeli mobil, atau rumah, atau konsol game, Anda dapat
melihat berapa banyak pinjaman akan dikenakan biaya bunga, atau lebih baik lagi, berapa lama
waktu yang dibutuhkan untuk menabung untuk membayar tunai.
deposito
Program singkat ini membantu Anda menabung untuk suatu tujuan dengan menghitung
berapa banyak uang yang harus disimpan dalam rekening berbunga, dan untuk berapa lama,
untuk mencapai tujuan Anda.
Misalnya, mungkin Anda ingin mendapatkan laptop gaming baru seharga $ 1000, dan
Anda menginginkannya satu tahun dari hari ini. Seperti yang ditunjukkan, Anda harus mulai
menyisihkan $80,69 setiap bulan di akun jika mendapat bunga 7%.
fv=float(input("Dollars goal: "))
ir=float(input("Interest rate: "))
mo=float(input("Months: "))
ir/=1200
dp=fv/((ir+1)**mo-1)*ir
s="Monthly deposits: ${:.2f}"
print(s.format(dp))
Nilai masa depan
Menabung untuk sesuatu yang ingin Anda beli di masa depan adalah cara yang bagus
untuk membuat uang Anda melangkah lebih jauh. Uang terakumulasi pada tingkat bunga
tertentu, daripada harus membayar bunga pinjaman, jadi pada dasarnya Anda menabung dengan
dua cara. Program ini memungkinkan Anda bereksperimen untuk melihat seberapa banyak Anda
akan menghemat, dan untuk membantu Anda tetap pada target saat Anda berinvestasi pada diri
sendiri.
Anda dimintai jumlah uang yang dapat Anda berikan setiap bulan, tingkat bunga tahunan
yang akan diakumulasikan oleh uang tersebut, dan jumlah tahun untuk menghitung
totalnya. Nilai masa depan adalah output. Dalam contoh yang ditunjukkan, $50 disimpan setiap
bulan, dengan tingkat bunga tahunan 7%, dan nilai masa depan setelah 3 tahun, dengan total
$1996,51 adalah output.
dp=float(input("Monthly deposit: "))

ir=float(input("Interest rate: "))
yr=float(input("Years: "))
ir/=1200
mo=yr*12
fv=dp*((ir+1)**mo-1)/ir
print("Future value: ${:,.2f}".format(fv))
minat
Program ini menghitung tingkat bunga yang dikenakan untuk pinjaman ketika pokok,
jumlah pembayaran bulanan, dan jumlah bulan untuk melakukan pembayaran diketahui. Tingkat
bunga tahunan yang dihitung adalah output.
Contoh menunjukkan tingkat persentase tahunan sebesar 10,49% dibebankan untuk

pinjaman sebesar $10.000 dengan pembayaran bulanan sebesar $325 selama periode 3 tahun,
atau 36 bulan.
p=float(input("Principal: "))
pmt=float(input("Monthly payments: "))
n=float(input("Months: "))
r,t=1,0
while t!=r:
t=r
r=pmt*((1+r)**n-1)/p/(1+r)**n
i=round(r*1200,2)
print("APR: {}%".format(i))
bulan
Program ini menghitung jumlah bulan yang diperlukan untuk melunasi sejumlah uang,
ketika pinjaman mengumpulkan biaya bunga.
Misalnya, Anda meminjam $1.000 dan setuju untuk membayar $25 setiap bulan dengan
bunga 7%. Program ini memberitahu Anda bahwa itu akan memakan waktu 49 bulan. Jumlah
bulan dibulatkan ke seluruh bulan terdekat. Kabar baiknya adalah pembayaran terakhir
kemungkinan akan kurang dari pembayaran lainnya.
r=float(input("Annual Interest: "))/1200
n,d=0,pmt+1
while d>pmt:
n+=1
d=round(p*(r*(1+r)**n)/((1+r)**n-1),2)
print("Months: ",n)
pembayaran
Program ini menghitung pembayaran bulanan untuk pinjaman berdasarkan jumlah, atau
pokok pinjaman, tingkat persentase tahunan, dan jumlah pembayaran bulanan yang harus
dilakukan.
Contoh menunjukkan pinjaman sebesar $5000 dengan tingkat bunga 9% akan

membutuhkan 24 pembayaran bulanan sebesar $228,42.
pmt=p*(r*(1+r)**n)/((1+r)**n-1)
pmt="${}".format(round(pmt,2))
print("Monthly payments: ",pmt)
Kepala Sekolah
Mengingat jumlah pembayaran bulanan untuk pinjaman, tingkat persentase tahunan untuk
pinjaman, dan jumlah bulan untuk melunasi pinjaman, program ini menghitung pokok pinjaman
asli.
Misalnya, dengan pembayaran $228,42 per bulan selama 24 bulan dengan bunga 9%,
jumlah pinjaman awal adalah $4999,92. Jumlah pinjaman yang sebenarnya mungkin $5000,
karena kesalahan pembulatan kecil dapat terakumulasi menjadi beberapa sen dengan mudah,
seperti dalam kasus ini.
p=pmt/(r*(1+r)**n)*((1+r)**n-1)
p="${}".format(round(p,2))
print("Principal: ",p)
6.
Perhitungan Numerik
Program-program dalam bab ini mencakup banyak perhitungan standar yang dapat
dilakukan oleh kalkulator dan komputer, dan yang mungkin berguna untuk studi atau pekerjaan
Anda. Programnya bervariasi mulai dari cara cepat untuk menemukan bilangan prima, hingga
menyelesaikan persamaan simultan, menemukan akar persamaan, menyediakan satu set lengkap
fungsi vektor, dan banyak lagi.
bin_dec_hex
Komputer menggunakan bit dan byte dan angka dalam format heksadesimal dan biner
sepanjang waktu. Program ini menunjukkan bagaimana nomor dapat dengan mudah dikonversi
ke dan dari salah satu format ini.
Misalnya, bilangan heksadesimal 0x4DF3 sama dengan desimal 19955, dan sama dengan
bilangan biner 0b100110111110011. Program meminta input dalam salah satu format, dan ketiga
format ditampilkan sebagai output:
Perhatikan bahwa ada cara yang lebih sederhana untuk mengonversi bilangan
heksadesimal atau biner ke desimal. Di shell, pada prompt >>> cukup masukkan nilainya,
pastikan Anda menambahkan awalan yang sesuai dari "0x" atau "0b". Nilai desimal akan
ditampilkan. Untuk mengonversi ke arah lain, dari desimal ke dua format lainnya, program ini
melakukan triknya. Nilai heksadesimal dapat dimasukkan dalam huruf besar atau kecil.
Beberapa baris terakhir dari program menunjukkan bagaimana memformat bilangan bulat
desimal untuk output dalam ketiga format angka.
print("Input one of the following")
print("0bnn.. binary")
print("nn..decimal")
print("0xnn.. hexadecimal")
n=input("Number? ").lower()
if n[0]=="0":
if n[1]=="b":
n=int(n[2:],2)
elif n[1]=="x":
n=int(n[2:],16)
else:
n=int(n)
print("Hex: ","0x{:X}".format(n))
print("Bin: ","0b{0:b}".format(n))
print("Dec: ",n)
binary_search
Program ini mencari akar dari suatu fungsi, atau di mana fungsi tersebut memotong sumbu
x pada y=0. Edit fungsi x Anda dalam fungsi f(x) yang dinamai dengan tepat, di bagian atas
daftar. Inilah fungsi yang akan kita gunakan dalam contoh:
Salah satu cara untuk menghitung pangkat x dalam Python adalah dengan dua tanda
bintang, dan itulah yang akan kita gunakan dalam contoh. (Cara lain adalah dengan
menggunakan fungsi pow() di perpustakaan matematika.)
def f(x):
return 0.7*x**3-7*x**2+3*x+17
Plot cepat fungsi ini pada kalkulator teknologi TI-Nspire™ CX II Anda (tidak
menggunakan Python) menunjukkan bahwa fungsi tersebut memiliki tiga akar yang terletak di
antara -5 dan +12 pada sumbu X. Program ini akan membantu Anda menemukan akar tersebut
dengan cepat dan efisien.
Fungsi root() dalam program ini melewati tiga nilai; nilai x awal untuk interval yang akan
diperiksa, nilai x akhir, dan jumlah langkah yang harus diambil di antara keduanya. Jumlah
langkah harus cukup sehingga fungsi zero-crossing tidak akan "dilangkahi". 100 bekerja dengan
baik dalam banyak kasus. Jika ada satu atau lebih akar dalam interval yang ditentukan, mereka
akan dikembalikan.
Dalam contoh ini, karena kita tahu tiga akar berada di antara -5 dan +12 (tepi grafik),
fungsi akar() dipanggil seperti ini: akar(-5, 12, 100), dan tiga akar yang dikembalikan akan
dicetak di layar.
Fungsi root() memecah interval besar menjadi banyak interval yang lebih kecil,
berdasarkan argumen ukuran langkah. Fungsi dipanggil untuk titik akhir dari interval yang lebih
kecil ini. Setiap kali dua nilai yang dikembalikan tidak memiliki tanda yang sama, fungsi root()
dipanggil untuk menggunakan pencarian biner untuk menemukan akar "tepat" dalam interval
tersebut.
Pencarian biner memotong interval antara x1 dan x2 menjadi dua, menghitung y pada titik
tengah tersebut, kemudian menentukan apakah sebuah akar harus terletak di suatu tempat di
sebelah kiri atau di sebelah kanan titik tengah tersebut. Nilai x1 diganti dengan nilai titik tengah
dalam satu kasus, dan x2 diganti sebaliknya. Pencarian diulangi dalam interval yang lebih ketat
ini, berulang-ulang, sampai perbedaan antara x1 dan x2 mendekati nol, pada nilai akar x.
Edit fungsi di bagian atas daftar, dan panggilan ke root() di akhir daftar untuk menemukan
akar fungsi Anda sendiri.
def f(x):
return 0.7*x**3-7*x**2+3*x+17
def roots(xmin,xmax,steps):
inc=(xmax-xmin)/steps
while xmin<xmax:
x=root(xmin,xmin+inc)
if x>=xmin:
print(x)
xmin+=inc
def root(x1,x2):
dif=0
y1=f(x1)
y2=f(x2)
while 1:
if y1*y2>0:
return x1-1
x=(x1+x2)/2
y=f(x)
if y1*y>0:
x1=x
y1=f(x1)
else:
x2=x
y2=f(x2)
if x1-x2!=dif:
dif=x1-x2
else:
return x
roots(-5,12,100)
faktor
Program ini menemukan semua faktor dari bilangan bulat. Fungsi factors() dilewatkan
bilangan bulat, dan mengembalikan daftar semua faktor primanya.
Misalnya, faktor prima dari 16 adalah empat 2s, faktor prima dari 12345 adalah 3, 5, dan
823, dan faktor prima dari 123454321 adalah 41, 41, 271, dan 271:
Ketika saya pertama kali membuat program ini, faktor-faktornya ditemukan dengan
membagi semua angka dari 2 ke angka yang diberikan untuk menemukan faktor-faktor yang
akan membagi secara merata. Ini bekerja dengan baik untuk bilangan bulat yang relatif kecil,
tetapi melambat untuk angka dalam puluhan ribu atau lebih besar. Untuk mempercepat (banyak!)
Saya meminjam fungsi next_prime() dan is_prime dari tempat lain dalam buku ini, dan hanya
memeriksa pembagian dengan bilangan prima, dan hanya hingga akar kuadrat dari bilangan bulat
yang diberikan. Ini menambahkan sedikit panjang ke daftar kode, tetapi hasil yang jauh lebih
cepat sepadan.
def factors(n):
factlist=[]
m=2
while n>1:
if n%m==0:
factlist.append(m)
n//=m
else:
m=next_prime(m)
if m*m>n:
factlist.append(n)
break
return factlist
def next_prime(n):
p=n+1
while not isPrime(p):
p+=1
return p
def isPrime(n):
primes = (
2,3,5,7,11,13,17,19,23,29,31,37,41,
43,47,53,59,61,67,71,73,79,83,89,97)
if n in primes:
return True
for m in primes:
if n%m==0:
return False
for m in range(primes[-1]+2,n//m+1,2):
if n%m==0:
return False
return True
n=int(input("Enter n: "))
print(factors(n))
fibonacci
Urutan fibonacci sangat menarik, dan program ini memungkinkan Anda menjelajahi fitur-
fiturnya secara interaktif. Dimulai dengan dua bilangan bulat, di mana nol dan satu sering kali
yang dipilih, jika Anda menambahkannya bersama-sama untuk ditambahkan ke daftar, lalu
tambahkan dua angka terakhir pada daftar itu untuk mendapatkan yang berikutnya, dan
seterusnya, Anda berakhir dengan a rasio antara dua angka terakhir pada daftar yang mendekati
rasio emas.
Cari di Internet untuk mempelajari lebih lanjut tentang rasio emas, karena ada banyak
fakta aneh di mana penjelasannya pada awalnya tampak tidak masuk akal. Misalnya, rasio emas
persis sama dengan 2 * sin(54 derajat). Alasannya ada hubungannya dengan bentuk segi lima,
tapi saya akan membiarkan Anda menemukan detailnya sendiri.
Fakta menarik lainnya adalah Anda tidak perlu memulai dengan 0 dan 1 untuk membentuk
barisan Fibonacci. Bahkan, Anda bisa mulai dengan dua angka, positif atau negatif, integer atau
float, dan rasio dua angka terakhir dalam daftar akan segera mendekati rasio emas. Itu aneh. Dan
Anda harus mencobanya!
Inilah hasil memulai dengan 0 dan 1, dan iterasi untuk menumbuhkan urutan 20 kali.
Seperti yang Anda lihat, rasio 10946 hingga 6765 sangat dekat dengan rasio emas. (Rasio
emas juga dapat dihitung sebagai satu ditambah akar kuadrat dari lima semua dibagi dua, dan
begitulah nilai yang lebih tepat dihitung pada baris terakhir dari output.)
Selanjutnya, mulai dengan -17,85 dan 97,65. Setelah hanya 20 penambahan rasio juga
dapat terlihat dengan cepat mendekati rasio emas:
a=float(input("Enter a: "))
b=float(input("Enter b: "))
n=int(input("Number of additions: "))
for i in range(n):
a,b=b,a+b
print("a: ",a)
print("b: ",b)
print("a / b: ",a/b)
print("b / a: ",b/a)
print("Golden: ",(1+5**.5)/2)
gcd_lcm
Program ini mencari GCD (pembagi persekutuan terbesar) dan KPK (kelipatan
persekutuan terkecil) dari dua bilangan bulat. KPK dari dua bilangan bulat adalah bilangan bulat
positif terbesar yang membagi keduanya secara merata. KPK dari dua bilangan bulat adalah
bilangan bulat positif terkecil yang merupakan kelipatan keduanya. Ternyata hasil kali kedua
bilangan tersebut adalah hasil kali KPK dan KPK.
Sebagai contoh, diberikan bilangan bulat 24 dan 56, kami menemukan GCD mereka
adalah 8, dan KPK mereka adalah 168.
def gcd(a,b):
while 1:
c=a-b*int(a/b)
a,b=b,c
if not c:
return a
def lcm(a,b):
return int(abs(a*b/gcd(a,b)))
a=int(input("Enter a: "))
b=int(input("Enter b: "))
print("GCD: ",gcd(a,b))
print("LCM: ",lcm(a,b))
rasio_emas
Cari di Internet untuk informasi menarik tentang Rasio Emas (GR), dan Anda akan
menemukan banyak cara untuk menghitung angka ini. Mungkin perhitungan yang paling
langsung adalah dengan menggunakan rumus ini:
Cara lain untuk menghitung GR adalah dengan Deret Fibonacci (lihat program fibonacci.)
Dalam program ini, iterasi sederhana yang dimulai dengan angka apa pun digunakan untuk
konvergen dengan cukup cepat pada nilai Rasio Emas. GR juga sama dengan 1 + 1/GR, yang
menyediakan cara yang apik untuk beralih ke nilainya.
Misalnya, dimulai dengan angka -123.4567, GR ditemukan hanya setelah 40 iterasi:
x=float(input("Enter any number: "))

y,n=0,0
while x!=y:
x,y,n=1+1/x,x,n+1
print("Iterations: ",n)
print("Golden: ",x)
print("Exact: ",(1+5**.5)/2)
newton
Program bin_search menemukan akar dari suatu fungsi f(x) menggunakan algoritma
pencarian biner, "terbagi dua". Program ini juga menemukan akar dari fungsi x, tetapi
menggunakan metode Newton, algoritma yang sangat keren yang dalam banyak kasus
menemukan akar dengan sangat efisien.
Metode Newton adalah metode iteratif yang menggunakan kemiringan fungsi (juga
dikenal sebagai turunan pertama) untuk membantu mengarahkan di mana fungsi melintasi sumbu
x. Berikut definisi formal, di mana f'(x) adalah kemiringan, atau turunan, dari f(x).
Untuk mendemonstrasikan program ini, kita akan menemukan tiga akar dari fungsi x yang
sama seperti pada program bin_search:
Sketsa cepat fungsi ini di kalkulator teknologi TI-Nspire™ CX II Anda menunjukkan ada
tiga akar antara -5 dan +12 di sepanjang sumbu x.
Program memanggil fungsi root() seperti dalam program binary_search, melewati batas
interval sepanjang sumbu x untuk mencari, dan jumlah langkah untuk memeriksa subinterval.
Perhatikan fungsi yang dikomentari bernama slope(x). Ada dua fungsi untuk menghitung
kemiringan, atau turunan pertama, dari f(x), dan Anda harus mengomentari satu atau yang
lain. Versi pertama dari slope() lebih fleksibel, karena tidak perlu mendefinisikan ulang setiap
kali fungsi f(x) didefinisikan ulang. Versi kedua diedit secara khusus untuk setiap f(x) jika Anda
mengetahui turunan pertama yang tepat. Sedikit Kalkulus berjalan jauh di sini, tetapi gunakan
saja fungsi lainnya, seperti yang ditunjukkan, jika menemukan turunan pertama terasa seperti
lereng yang licin bagi Anda saat ini. Boleh dikatakan.
def f(x):
return 0.7*x**3-7*x**2+3*x+17
def slope(x):
dx=0.0001
dy=f(x+dx)-f(x)
return dy/dx
##def slope(x):
## return 2.1*x*x-14*x+3
def roots(xmin,xmax,steps):
inc=(xmax-xmin)/steps
for i in range(steps):
root(xmin,xmin+inc)
xmin+=inc
def root(x1,x2):
if f(x1)*f(x2)<=0:
x,a,b=x1,x2,x2
while x!=b:
a,b=x,a
x=x-f(x)/slope(x)
print(x)
roots(-5,12,100)
bilangan prima
Program ini menemukan n bilangan prima dengan pencarian dimulai dari sembarang
bilangan bulat. Bilangan prima adalah bilangan bulat yang hanya dapat dibagi rata dengan 1 dan
dirinya sendiri. Misalnya, 7 adalah bilangan prima, 8 bukan karena dapat dibagi 2, dan 9 bukan
karena dapat dibagi 3.
Program ini menyediakan dua fungsi berguna yang bekerja bersama, atau Anda dapat
memanggilnya secara terpisah jika diinginkan. Fungsi pertama, isPrime() hanya mengembalikan
True jika bilangan bulat yang diteruskan adalah prima, dan False sebaliknya. Fungsi
next_prime() dilewatkan bilangan bulat apa pun yang bertambah hingga bilangan prima
berikutnya ditemukan.
Berikut ini contoh lari di mana tujuh bilangan prima mulai dari 900 ditemukan:
def isPrime(n):
if n%2==0:
return False
m=3
while m<=n/m:
if n%m==0:
return False
m+=2
return True
def next_prime(n):
p=n+2 if n%2 else n+1
while isPrime(p)==False:
p+=2
return p
x=int(input('Enter starting n: '))-1

count=int(input('Find how many primes: '))
while count>0:
count-=1
x=next_prime(x)
print(x)
kuadrat
Rumus kuadrat memungkinkan kita menemukan akar fungsi kuadrat. Program ini

menghitung akar tersebut, jika ada.
Pertimbangkan fungsi parabola (kuadrat) berikut, seperti yang digambarkan pada

kalkulator teknologi TI-Nspire™ CX II Anda:
Anda meneruskan tiga nilai a, b, dan c yang membentuk persamaan ini ke fungsi akar, dan
jika dua akar ada, sebuah pesan dikembalikan dengan mencantumkan keduanya.
Berdasarkan diskriminan, variabel d dalam fungsi root(), mungkin ada nol atau hanya satu
root dalam beberapa kasus. Pesan yang menunjukkan hasil ini dikembalikan jika demikian.
def quadratic_roots(a,b,c):
d=b*b-4*a*c
if d<0:
return "No real roots"
elif d==0:
return "One root: {}".format(-b/(2*a))
else:
x1=(-b-d**.5)/2/a
x2=(-b+d**.5)/2/a
return "Roots: \n{}\n{}".format(x1,x2)
print("Quadratic Ax^2+Bx+C=0")
a=float(input("A? "))
b=float(input("B? "))
c=float(input("C? "))
print(quadratic_roots(a,b,c))
rect_polar
Bilangan kompleks adalah bagian dari Python, membuatnya mudah untuk memecahkan
banyak elektronik canggih dan perhitungan teknik lainnya. Namun, seringkali lebih mudah untuk
dapat mengkonversi dengan cepat dan mudah antara koordinat kartesius, atau persegi panjang,
dan koordinat kutub standar, di mana sudut dinyatakan dalam derajat.
Saat program ini dimulai, Anda akan melihat pesan yang menyatakan bahwa fungsi rp()
dan pr() sekarang tersedia di shell, dan tidak ada lagi yang terjadi. Kedua fungsi tersebut
kemudian ditentukan, dan Anda dapat menggunakannya secara manual sebanyak yang
diperlukan.
Misalnya, untuk mengonversi (3,4) dari persegi panjang ke kutub, lalu mengonversi
(17,45) dari kutub ke persegi panjang, jalankan program untuk mendefinisikan fungsi, lalu
ketikkan fungsi di shell dan berikan angka-angka ini sebagai parameter.
Berikut adalah persamaan yang digunakan untuk melakukan konversi. Perhatikan bahwa

sudut kutub dihitung dalam radian dengan Python, tetapi fungsi matematika derajat()
memungkinkan kita untuk dengan mudah mengonversinya.
from math import *
def rp(x,y):
r=(x*x+y*y)**.5
t=degrees(atan2(y,x))
return (r,t)
def pr(r,t):
a=radians(t)
x=r*cos(a)
y=r*sin(a)
return (x,y)

print("rp(x,y) and pr(r, ) are")
print("now available in the shell")
simultan_eq
Program ini memecahkan persamaan simultan dari berbagai ukuran, meskipun terlalu
banyak persamaan/tidak diketahui bisa sulit untuk dikerjakan, dan itu bisa memperlambat
kalkulator Anda hingga merangkak. Sebagian besar waktu orang bekerja dengan ukuran 2, 3,
atau 4 persamaan simultan, dan program ini menanganinya dengan baik.
Misalnya, jika diberikan dua persamaan berikut, berapakah nilai x dan y yang memenuhi
keduanya?
Program pertama meminta jumlah persamaan, kemudian meminta koefisien dan konstanta
untuk masing-masing secara bergantian, seperti yang ditunjukkan di sini untuk contoh kita:
Saat Anda memasukkan konstanta terakhir, jawabannya ditemukan dan ditampilkan

sebagai a1, a2, ... dan seterusnya.
Jika Anda memeriksa dan memasukkan -1 dan 2 untuk x dan y dalam persamaan asli,
Anda akan melihat bahwa kedua persamaan terpenuhi.
n=int(input("Number of equations: "))
a=[]
for j in range(n):
coef=[]
print("")
for i in range(n):
p="Eq {} Coef {}: ".format(j+1,i+1)
x=float(input(p))
coef.append(x)
k=float(input("Constant:"))
coef.append(k)
a.append(coef)
for j in range(n):
ok=False
for i in range(n):
if i>=j:
if a[i][j]:
ok=True
break
if not ok:
print("\nNo solution")
else:
for k in range(n+1):
a[j][k],a[i][k]=a[i][k],a[j][k]
y=1/a[j][j]
a[j][k]*=y
for i in range(n):
if i!=j:
y=-a[i][j]
a[i][k]+=y*a[j][k]
if ok:
print("")
for i in range(n):
print("a{} = {}".format(i+1,a[i][n]))
vektor
Jika Anda bekerja dengan vektor, program ini bisa sangat berguna. Sembilan fungsi
berbeda mencakup semua dasar pemrosesan satu, dua, atau tiga vektor 3D sekaligus.
Fungsi umumnya sangat singkat dan efisien. Saat Anda menjalankan program, fungsinya
ditentukan, dan satu instruksi singkat ditampilkan sebagai pengingat bagaimana
memulainya. Cukup ketik "v()" untuk menjalankan fungsi yang menampilkan daftar semua
sembilan fungsi vektor. Ketik ini kapan saja untuk menyegarkan ingatan Anda tentang apa yang
tersedia, dan parameter apa yang diharapkan setiap fungsi.
Parameter berlabel "v" mengharapkan daftar angka untuk mewakili vektor. Anda dapat
menggunakan vektor dimensi 2, 3 atau lebih tinggi dalam banyak kasus. Perhatikan bahwa
fungsi cross() dan stp() hanya berfungsi dalam tiga dimensi.
Untuk contoh kerja, kami akan menetapkan vektor 2D ke [3,4], dan yang kedua ke [5,-
2]. Fungsi add() kemudian menemukan jumlah dari kedua vektor ini menjadi [8,2].
Anda juga dapat meneruskan vektor sebagai daftar secara langsung dalam pemanggilan
fungsi, daripada menyimpannya terlebih dahulu dalam variabel. Kedua teknik bekerja dengan
baik. Berikut adalah contoh mencari besar vektor 3D [3,4,-5], dan kemudian mencari sudut
dalam derajat antara dua vektor 3D di ruang angkasa.
from math import *
def add(v1,v2):
return [a+b for a,b in zip(v1,v2)]
def sub(v1,v2):
return [a-b for a,b in zip(v1,v2)]
def dot(v1,v2):
return sum([a*b for a,b in zip(v1,v2)])
def ang(v1,v2):
m1=sum(i*i for i in v1)**.5
m2=sum(i*i for i in v2)**.5
d=sum([a*b for a,b in zip(v1,v2)])
return degrees(acos(d/m1/m2))
def cross(v1,v2):
a,b,c=v1
d,e,f=v2
return [b*f-c*e,c*d-a*f,a*e-b*d]
def stp(v1,v2,v3):
a,b,c=v1
d,e,f=v2
g,h,i=v3
p=a*e*i+b*f*g+c*d*h
m=a*f*h+b*d*i+c*e*g
return p-m
def mul(v,n):
return [i*n for i in v]
def mag(v):
return sum(i*i for i in v)**.5
def unit(v):
m=mag(v)
return [i/m for i in v]
def v():
print("add(v,v)")
print("sub(v,v)")
print("dot(v,v)")
print("ang(v,v)")
print("cross(v,v)")
print("stp(v,v,v)")
print("mul(v,n)")
print("mag(v)")
print("unit(v)")
print("Vectors...")
print("v() to list functions")
7.
Program Berguna Lainnya
Bab ini menyajikan beberapa program yang menyenangkan untuk dibuat, tetapi tidak
cocok dengan bab-bab lainnya. Salah satu contoh nyata adalah program yang menghitung meter
kubik beton. Contoh mengerikan lainnya menghitung indeks angin dingin. Bahkan ada program
rahasia yang tidak akan saya ceritakan di sini. Pergi temukan sendiri!
konkret
Masalah yang sangat umum dengan proyek konstruksi adalah menentukan berapa meter
kubik beton yang dipesan. Biasanya, jalan masuk, trotoar, atau area lain diukur dalam panjang
dan lebar kaki, dan kedalaman inci. Program ini mengambil ketiga nilai ini, melakukan konversi
yang tepat ke unit umum, dan mengalikannya untuk mendapatkan yard kubik.
Tantangan besar untuk menguji keterampilan pemrograman Python Anda adalah

mengubah program ini untuk menggunakan semua unit metrik. Saya menyimpan unit dalam
kaki, inci, dan yard kubik agar sesuai dengan unit standar yang digunakan di Amerika Serikat.
Misalnya, ketebalan jalan masuk mobil penumpang yang disarankan adalah 4 inci. Berapa
meter kubik beton yang dibutuhkan untuk jalan masuk selebar 12 kaki yang panjangnya 15 kaki?
print("Concrete volume")
h=float(input("Length (ft): "))
w=float(input("Width (ft): "))
d=float(input("Depth (in): "))
yd=round(h*w*d/324,2)
print("Cubic yards:",yd)
kode_kunci
Modul ti_system menyediakan beberapa fungsi yang berguna untuk mengontrol program
Anda, seperti get_key(). get_key() mengembalikan string yang merupakan representasi karakter
dari tombol yang ditekan. Misalnya, jika tombol [esc] ditekan, get_key() mengembalikan "esc".
Ini cukup jelas, tetapi sulit untuk menebak dengan tepat string apa yang akan
dikembalikan ketika beberapa tombol ditekan. sebagai salah satu contoh saja, tombol [10^x]
mengembalikan "10power".
Program kecil ini membantu Anda mengetahui semua kode untuk semua penekanan
tombol. Program menggunakan loop while untuk melihat penekanan tombol, mencetak
representasi string dari semua penekanan tombol, berhenti hanya ketika tombol [esc] ditekan.
Perhatikan bahwa ada dua cara untuk memanggil get_key(). Jika tidak ada parameter yang
dilewatkan dalam tanda kurung, fungsi akan langsung kembali. Dalam program ini sebuah digit
1 dilewatkan ke get_key(), menyebabkannya menunggu sampai sebuah tombol ditekan sebelum
melanjutkan. Ini bekerja lebih baik untuk apa yang kami coba capai di sini, tetapi pengembalian
instan dapat berguna dalam beberapa jenis program interaktif.
Berikut adalah contoh run di mana beberapa tombol ditekan.
while True:
k=get_key(1)
print(k)
if k=="esc":
break
laser_jarak
Jika Anda memiliki perangkat pengukur jarak laser kecil (sangat menyenangkan), Anda
dapat menggunakannya bersama dengan program ini untuk mengukur jarak di sepanjang garis
yang sulit dijangkau.
Misalnya, Anda ingin mengukur tinggi dinding, dari lantai ke langit-langit, tetapi Anda
tidak ingin menaiki tangga. Anda dapat mengukur jarak dari ketinggian mata, tempat Anda
memegang perangkat laser, ke lantai, lalu ke dinding di depan Anda setinggi mata, lalu ke tepi
atas dinding. Ini ditandai sebagai titik a, b, dan c pada diagram ini:
Jika jarak ke a adalah 9 kaki 3 inci, ke b adalah 7 kaki 9 inci, dan ke c adalah 12 kaki 10
inci, maka program menghitung tinggi dinding dari a ke c sebagai 14 kaki 10 inci.
Masukkan tiga jarak secara berurutan, dalam urutan yang muncul di sepanjang garis yang
Anda ukur. Bahkan jika pengukuran pertama atau terakhir adalah pengukuran yang tegak lurus
terhadap garis, jarak antara titik-titik yang tidak tegak lurus akan selalu dihitung dengan benar.
Misalnya, katakanlah Anda memiliki lukisan raksasa di dinding yang tinggi dan Anda
ingin mengukur tingginya, seperti mengukur b ke c dalam diagram ini:
Dalam hal ini, masukkan jarak ke a, b, dan c dalam urutan itu (atau dalam c, b, urutan -
pertahankan agar tetap berurutan di sepanjang garis.) Dalam hal ini jarak b ke c akan
dihitung. Berikut ini contoh lari yang menunjukkan tinggi yang dihitung dari b ke c 10 kaki 8
inci.
print("Enter 'ft in' to 3 pts in")
print("a row, where one point is")
print("perpendicular...")
a=input("Distance a ... ft in: ")

a=(a.strip()+' 0').split()
a=float(a[0])+float(a[1])/12
b=input("Distance b ... ft in: ")

b=(b.strip()+' 0').split()
b=float(b[0])+float(b[1])/12
c=input("Distance c ... ft in: ")

c=(c.strip()+' 0').split()
c=float(c[0])+float(c[1])/12
ft=0
if a>b and b<c:

d=(a*a-b*b)**0.5
e=(c*c-b*b)**0.5
ft=d+e
if a<b and b<c:

d=(b*b-a*a)**0.5
e=(c*c-a*a)**0.5
ft=e-d

if a>b and b>c:
d=(b*b-c*c)**0.5
e=(a*a-c*c)**0.5
ft=e-d
feet=int(ft)
inch=round((ft-feet)*12)
print("Distance between the two")
print("non-perpendicular points:")
print('ft in: ',feet,inch)
mil per jam
Kalkulator teknologi TI-Nspire™ CX II Anda memiliki jam (tidak semua kalkulator dapat
mengetahui tanggal dan waktu.) Dengan menggunakan fungsi get_key() yang pertama kali
dijelaskan dalam program get_key di awal bab ini, Anda dapat membuat jenis stopwatch . Anda
menekan satu tombol untuk memulai pengaturan waktu saat Anda melewati penanda mil di
mobil yang Anda kendarai, dan tekan tombol lain mana pun saat Anda melewati penanda mil
berikutnya. Sedikit matematika dalam program kemudian menghitung rata-rata mil per jam.
Dua detail penting yang perlu diperhatikan. Pertama, jangan mengemudi dan menjalankan
Python secara bersamaan! Biarkan orang lain mengemudi saat Anda memeriksa
kecepatannya. Kedua, ini memberikan kecepatan rata-rata saat menempuh jarak satu mil. Hal ini
sangat mungkin untuk mengemudi 40 mil per jam untuk sebagian mil, dan 60 mil per jam sisa
mil, dan rata-rata di 50 mil per jam. Tetap ingatlah selalu.
Tantangan yang perlu dipertimbangkan adalah memodifikasi program untuk pengukuran

metrik. Seberapa cepat mobil melaju dalam km/jam melewati jalan sepanjang 1 km (atau 1 mil
jika hanya ada penanda mil)?
Berikut adalah contoh lari, di mana mil membutuhkan waktu sekitar 55 detik.
print(" ")
print("Press any key at first milepost")
get_key(1)
t1=get_time_ms()
print("Press any key at next milepost")
get_key(1)
t2=get_time_ms()
s=(t2-t1)/1000
h=s/3600
mph=round(1/h)
print("MPH: ",mph)
rahasia
Program ini memungkinkan Anda mengenkripsi dan mendekripsi pesan

rahasia. Tindakannya sedikit rumit, tetapi untuk pesan singkat, seperti kata sandi yang digunakan
di tempat lain yang ingin Anda jaga agar tetap aman, program ini memang memberikan tingkat
keamanan yang cukup tinggi.
Misalnya, mari kita mengenkripsi frase spy-talk "The dew is on the roses" menggunakan
kunci "abc123". Pertama, pilih 1 untuk melakukan enkripsi, masukkan frase, lalu masukkan
kunci.
Data terenkripsi ditampilkan sebagai blok enam karakter heksadesimal. Itulah data yang
akan Anda tulis dan simpan, atau kirimkan ke teman mata-mata Anda di suatu tempat.
Untuk mendekripsi pesan, pilih 2 untuk memulai dekripsi. Pada setiap "Detik?" prompt
masukkan satu blok rahasia karakter heksadesimal terenkripsi. Huruf kecil tidak apa-apa, dan itu
sebenarnya membuatnya lebih mudah untuk mengetiknya.
Lanjutkan sampai semua blok kode dimasukkan. Perhatikan bahwa dalam beberapa kasus
blok terakhir mungkin memiliki kurang dari empat karakter, tetapi tidak apa-apa, masukkan saja
apa yang ditampilkan setelah enkripsi.
Setelah blok terakhir dimasukkan, tekan [enter] untuk terakhir kalinya untuk mendapatkan
prompt untuk Kunci. Masukkan kunci rahasia (Anda dan teman mata-mata Anda akan
merahasiakan kunci ini), dan pesan asli akan muncul setelah sedikit pemrosesan.
m1=17
n1=23
m2=145
n2=87
a=[]
def rseed(s):
for c in s:
a.append(ord(c))
for i in range(97):
rbyte()
def rbyte():
la=len(a)
for i in range(la):
j=(i+1)%la
a[i]+=a[j]
a[i]+=i*m1+n1
a[i]+=j*m2+n2
a[i]%=256
return a[0]
def hexchr(c):
return ("0"+hex(c)[2:])[-2:].upper()
def chrhex(h):
return eval("0x"+h)
def cls():
for i in range(20):
print()
print("1. Encrypt")
print("2. Decrypt")
n=int(input("? "))
s=''
x=0
if n==1:
msg=input("Msg? ")
key=input("Key? ")
cls()
rseed(key)
for c in msg:
b=ord(c)^rbyte()
s+=hexchr(b)
x+=1
if not x%3:
print(s)
s=''
print(s)
s=''
if n==2:
sec=""
x=1
while x:
x=input("Sec? ")
sec+=x
sec=sec.replace(' ','').upper()
key=input("Key? ")
rseed(key)
i=0
while i < len(sec):
b=chrhex(sec[i:i+2])
s+=chr(b^rbyte())
i+=2
cls()
print(s)
bola_basah
Berita utama baru-baru ini berbicara tentang bahaya orang yang kepanasan dan bahkan
sekarat di sekitar planet ini karena perubahan iklim menyebabkan peningkatan jumlah peristiwa
panas yang berlebihan. Ini adalah masalah nyata. Suhu udara adalah satu hal yang harus
diperhatikan, tetapi yang lebih penting adalah apa yang disebut suhu bola basah, efek gabungan
suhu dan kelembaban relatif.
Kami berkeringat untuk mendinginkan. Saat air menguap dari permukaan, suhunya

turun. Dengan kelembaban relatif yang rendah, efek pendinginan lebih besar, dan dengan
kelembaban relatif yang lebih tinggi, penguapan melambat dan lebih sulit untuk
didinginkan. Gurun yang panas tapi kering bisa kurang berbahaya bagi kehidupan manusia
daripada lingkungan perkotaan yang panas dan lembab!
Psikrometer mengukur suhu bola basah. Sebuah tabung kecil berisi kain basah dililitkan di
ujung bohlam termometer, dan diayunkan di udara untuk memaksimalkan penguapan. Ada
batasan seberapa dingin termometer ini karena penguapan, dan itu adalah suhu bola basah. Suhu
bola basah adalah fungsi dari suhu udara aktual dan kelembaban relatif.
Sekarang inilah hal yang berbahaya. Jika suhu bola basah lebih tinggi dari suhu tubuh,
tidak peduli seberapa banyak Anda berkeringat atau seberapa cepat kipas yang Anda tiup, tidak
mungkin untuk menjadi dingin. Itulah mengapa penting untuk mengetahui suhu bola basah saat
panas!
Ada rumus matematika yang sangat rumit untuk menghitung suhu bola basah ketika suhu
udara dan kelembaban relatif diketahui. Tidak seperti kebanyakan algoritma, persamaan ini
sebenarnya ditemukan oleh program kecerdasan buatan. Ceritanya terlalu rumit untuk masuk ke
sini, tetapi jika Anda tertarik, cari di Internet untuk mempelajari lebih lanjut. Program ini
menggunakan persamaan untuk menghitung suhu bola basah. Selain itu, jika Anda mengetahui
dua dari tiga faktor; suhu udara, kelembaban relatif, dan suhu bola basah, program ini akan
menghitung diketahui ketiga.
Tiga fungsi ditunjukkan saat Anda menjalankan program ini, semuanya menggunakan
rangkaian angka yang sama. Jika suhu udara 30C, dan kelembaban relatif 50%, maka suhu bola
basah sangat dekat dengan 22,3C. Pasangan parameter ini diteruskan ke setiap fungsi untuk
menghitung yang ketiga. Seperti yang Anda lihat, hasilnya konsisten.
from math import *
def wet_bulb(t,rh):
a=t*atan(0.151977*(rh+8.313659)**.5)
b=atan(t+rh)-atan(rh-1.676331)
c=0.00391838*rh**(1.5)*atan(0.023101*rh)
d=-4.686035
tw=a+b+c+d
return tw
def temperature(tw,rh):
t=-20
while t<50:
if wet_bulb(t,rh)>=tw:
return t
t+=0.1
return 999
def relative_humidity(t,tw):
rh=0
while rh<100:
if wet_bulb(t,rh)>=tw:
return rh
rh+=.1
return 999
print(" ")
print("Air Temp: 30")
print("Rel Hum: 50")
print("Wet Bulb: ",wet_bulb(30,50))
print(" ")
print("Wet Bulb: 22.3")
print("Rel Hum: 50")
print("Air Temp: ",temperature(22.3,50))
print(" ")
print("Air Temp: 30")
print("Wet Bulb: 22.3")
print("Rel Hum: ",relative_humidity(30,22.3))
angin dingin
Saat angin bertiup, udara terasa lebih dingin karena lebih cepat menguras panas dari tubuh
Anda. Ada perhitungan standar untuk faktor angin dingin ini, dan program ini menanganinya
untuk Anda.
Masukkan suhu udara aktual dalam derajat F, dan kecepatan angin dalam mil per
jam. Indeks angin dingin adalah output. Misalnya, pada 30 mph, suhu udara nyata 25F terasa
sama dengan 8F.
f=float(input("Temp (F): "))

w=float(input("Wind (mph): "))
v=w**.16
wc=35.74+.6215*f-35.75*v+.4275*f*v
print("Wind Chill Index:",round(wc))
8.
Ilmu ukur bidang
Inti dari sebagian besar sistem permainan digital adalah banyak perhitungan yang penting
untuk mensimulasikan dunia nyata. Bab ini menyajikan perhitungan dua dimensi umum dan
transformasi koordinat yang digunakan untuk banyak tujuan, termasuk membuat semua jenis
grafik dan animasi game.
arc_parts
Diberikan dua dari empat parameter yang menggambarkan bagian dari lingkaran, program
ini menghitung dua bagian yang tidak diketahui. Bagian-bagiannya adalah panjang busur,
panjang tali busur, sudut pusat dan jari-jari lingkaran yang mendefinisikan busur.
Misalnya, rel kereta api akan dirancang untuk berbelok 45 derajat, di mana jarak garis
lurus (kord) antara titik akhir belokan adalah 2.021 meter. Berapa panjang lintasannya? Seperti
yang ditunjukkan pada contoh, lintasan (panjang busur) sekitar 2.074 meter.
Masukkan dua nilai yang diketahui saat diminta, dan cukup tekan [enter] untuk yang tidak
diketahui.
from math import *
def arcs(a,r,c,s):
if a:
if r:
s=r*a
elif c:
r=c/2/sin(a/2)
else:
r=s/a
elif r:
if c:
a=2*asin(c/r/2)
else:
a=s/r
else:
a=.1
t=0
while a!=t:
t=a
a=2*s*sin(a/2)/c
r=s/a
c=2*r*sin(a/2)
s=r*a
return [a,r,c,s]
print("\n\nInput two known values\n")

a=input("Angle (deg): ")
a=radians(a)
r=input("Radius: ")
c=input("Chord length: ")
c=float(c) if c else 0
s=input("Arc length: ")
s=float(s) if s else 0
a,r,c,s=arcs(a,r,c,s)
a=degrees(a)
print("\nAngle: ",a)
print("Radius: ",r)
print("Chord: ",c)
print("Arc: ",s)
area_3p
Tiga titik x,y pada bidang membentuk segitiga. Program ini menghitung luas segitiga jika
diberikan tiga titik.
Pada contoh yang ditunjukkan, setelah mengedit tiga koordinat ke dalam program, luas
segitiga dihitung sebagai 20 satuan persegi.
def area_3p(p1,p2,p3):
x1,y1=p1
x2,y2=p2
x3,y3=p3
a=x1*y2+x2*y3+x3*y1
b=x1*y3+x2*y1+x3*y2
return abs((a-b)/2)
p1=[10,7]
p2=[8,1]
p3=[2,3]
print("Area: ",area_3p(p1,p2,p3))
area_3s
Rumus Heron memungkinkan kita menemukan luas segitiga jika panjang ketiga sisinya
diketahui, tanpa harus menghitung sudut atau jarak lainnya terlebih dahulu. Berikut rumus,
diberikan sisi dengan panjang a, b, dan c:
Misalnya, berapa luas segitiga yang memiliki sisi 7, 11, dan 17 cm? Masukkan ketiga nilai
ini ke dalam program dan jawabannya akan dihitung kira-kira 24,44 cm persegi.
def area_3s(a,b,c):
s=(a+b+c)/2
return (s*(s-a)*(s-b)*(s-c))**.5
a=float(input("Side a: "))
b=float(input("Side b: "))
c=float(input("Side c: "))
print("Area: ",area_3s(a,b,c))
area_pts
Program ini menghitung luas poligon bentuk apa pun. Koordinat X,Y dari setiap simpul
dimasukkan dengan mengedit daftar titik secara langsung dalam kode, dalam fungsi load_pts() di
bagian atas daftar.
Masukkan poin dengan "berjalan di sekitar" poligon di kedua arah. Daftar program

menunjukkan contoh poligon dengan enam simpul, seperti yang ditunjukkan di sini:
Ares poligon ditemukan dengan secara efektif memecah poligon menjadi segitiga yang
lebih kecil dan menambahkan luas masing-masing.
from math import *
def load_pts():
pts=[]
pts.append([4.5,-1.5])
pts.append([8,2])
pts.append([.5,4])
pts.append([-1.5,.5])
pts.append([.5,-2])
pts.append([1,1])
return pts
def area_pts(pts):
area=0
pts.append(pts[0])
for i in range(len(pts)-1):
a=pts[i][0]+pts[i+1][0]
b=pts[i][1]-pts[i+1][1]
area+=a*b
return abs(area/2)
pts=load_pts()
area=area_pts(pts)
print("Area: ",area)
lingkaran
Program ini mencari pusat dan jari-jari lingkaran yang hanya menyentuh tiga titik pada
bidang x,y. Cara lain untuk menempatkan ini adalah program menemukan titik yang berjarak
sama dari tiga titik yang diberikan. Tentu hal ini tidak akan berhasil jika ketiga titik tersebut
berada dalam satu garis lurus. Program mendeteksi kondisi ini dan mencetak "Bukan lingkaran"
jika ini masalahnya.
Misalnya, temukan lingkaran yang melalui titik (3,12), (10,13), dan (7,4):
def load_3p():
p1=[3,12]
p2=[10,13]
p3=[7,4]
return (p1,p2,p3)
def circle_3p(p1,p2,p3):
x1,y1=p1
x2,y2=p2
x3,y3=p3
A=(x1*(y2-y3)-
y1*(x2-x3)+
x2*y3-x3*y2)
B=((x1*x1+y1*y1)*
(y3-y2)+
(x2*x2+y2*y2)*
(y1-y3)+
(x3*x3+y3*y3)*
(y2-y1))
C=((x1*x1+y1*y1)*
(x2-x3)+
(x2*x2+y2*y2)*
(x3-x1)+
(x3*x3+y3*y3)*
(x1-x2))
if A==0:
return (0,0,0)
xc=-B/A/2
yc=-C/A/2
r=(((xc-x1)**2+(yc-y1)**2)**.5)
return (xc,yc,r)
p1,p2,p3=load_3p()
xc,yc,r=circle_3p(p1,p2,p3)
print("p1: ",p1)
print("p2: ",p2)
print("p3: ",p3)
print("xc: ",xc)
print("yc: ",yc)
print("r: ",r)
jarak
Dua titik pada bidang x,y dipisahkan oleh suatu jarak garis lurus. Program singkat ini
membuat fungsi yang menggunakan Teorema Pythagoras untuk mencari jarak tersebut.
Contoh menemukan jarak antara titik [6, 5] dan [2, 3] dan menampilkan hasilnya untuk
verifikasi. Setelah menjalankan program, Anda dapat menemukan jarak lain dengan memanggil
fungsi distance() secara manual saat berada di shell. Pastikan untuk melewatkan dua variabel,
masing-masing daftar dengan dua angka yang mewakili nilai koordinat x dan y.
Misalnya, untuk mengulang penghitungan jarak yang sama secara manual, ketik
"jarak([6,5],[2,3])" di shell, seperti yang ditunjukkan.
def distance(p1,p2):
x1,y1=p1
x2,y2=p2
d=((x2-x1)**2+(y2-y1)**2)**.5
return d
p1=[6,5]
p2=[2,3]
d=distance(p1,p2)
print("p1: ",p1)
print("p2: ",p2)
print("distance: ",d)
bagi_baris
Program ini menyajikan fungsi yang membagi garis pada bidang x,y menjadi n bagian
yang sama. divide_lines() membutuhkan tiga argumen. Dua yang pertama adalah daftar, masing-
masing berisi dua angka yang mendefinisikan koordinat x,y. Parameter ketiga bernama segs, dan
mengontrol berapa banyak segmen yang sama untuk membagi garis menjadi. Seringkali, hanya
titik tengah segmen garis yang diinginkan. Dalam hal ini lulus 2 untuk segs.
Contoh membagi segmen garis dari titik (3,2) ke titik (9,5) menjadi tiga bagian yang
sama. Daftar semua koordinat di sepanjang segmen garis dikembalikan, dan itu termasuk
pasangan titik asli di setiap akhir daftar.
Jika Anda membagi garis menjadi banyak bagian, Anda dapat menggulir layar untuk
melihat semua hasilnya.
def divide_line(p1,p2,n):
pts=[]
for i in range(n+1):
x=p1[0]+(p2[0]-p1[0])*i/n
y=p1[1]+(p2[1]-p1[1])*i/n
pts.append([x,y])
return pts
p1=[3,2]
p2=[9,5]
segs=3
pts=divide_line(p1,p2,segs)
for pt in pts:
print(pt)
baris_2p
Program ini menghitung beberapa ciri garis pada bidang yang ditentukan oleh dua
titik. Misalnya, mengingat titik [4,3] dan [-5, -9], apa yang dapat kita ketahui tentang garis yang
melewatinya?
Kemiringan (m) adalah 1,625, intersep x (xi) sekitar 0,5385, dan intersep y (yi) adalah -
0,875. Jika digabungkan, persamaan garisnya adalah y=1,625*x-0,875.
def line_2p(p1,p2):
x1,y1=p1
x2,y2=p2
m = (y2 - y1) / (x2 - x1)
a = x1-y1/m
b = y1-m*x1
return (m,a,b)
p1=[3,4]
p2=[-5,-9]
m,a,b=line_2p(p1,p2)
print("p1: ",p1)
print("p2: ",p2)
print("slope: ",m)
print("x int: ",a)
print("y int: ",b)
f="y={}*x+{}"
if b<0: f=f.replace("+","")
print(f.format(m,b))
line_pt_slope
Program ini mendefinisikan fungsi yang menemukan parameter umum dari garis yang
diberikan titik dan kemiringan. Misalnya, apa garis yang melalui titik [3,4] dan memiliki
kemiringan 0,5? Fungsi mengembalikan perpotongan x dan y, ditambah kemiringan garis. Mirip
dengan program line_2p yang dijelaskan sebelumnya, ini menyediakan semua yang diperlukan
untuk menampilkan semua informasi umum tentang garis, termasuk persamaannya.
def line_pt_slope(pt,m):
x,y=pt
b=y-m*x
a=x-y/m
return (m,a,b)
pt=[3,4]
m=0.5
m,a,b=line_pt_slope(pt,m)
print("pt: ",pt)
print("slope: ",m)
print("x int: ",a)
print("y int: ",b)
f="y={}*x+{}"
if b<0: f=f.replace("+","")
print(f.format(m,b))
mengubah
Permainan grafis komputer membutuhkan banyak matematika kecepatan tinggi untuk

menjaga aksi tetap realistis dan halus. Salah satu algoritma inti adalah kemampuan untuk
memutar sebuah titik pada bidang x,y di sekitar titik asal dengan beberapa sudut. Ini adalah
penyederhanaan besar dari persyaratan pemrograman game, tapi hei, ini permulaan!
Fungsi rotate() memungkinkan Anda melewatkan titik sebagai daftar yang berisi koordinat
x dan y, dan jumlah rotasi dalam derajat. Koordinat diputar di sekitar titik asal dengan sudut
yang dikonversi ke radian, dan nilai koordinat baru dikembalikan.
Fungsi translate() diberikan poin plus nilai x dan y untuk terjemahan. Intinya

diterjemahkan ke lokasi baru dengan penambahan sederhana dari jumlah terjemahan. Nilai x dan
y yang dihasilkan dikembalikan.
Misalnya, titik (2,3) akan berakhir di (6, 7)) setelah translasi (4,4), dan di dekat titik
(1.035,3.454) setelah rotasi 17 derajat di sekitar titik asal.
from math import *
def translate(p,dx,dy):
x,y=p
return (x+dx,y+dy)
def rotate(p,a):
x,y=p
r=radians(a)
xr=x*cos(r)-y*sin(r)
yr=x*sin(r)+y*cos(r)
return (xr,yr)
p=[2,3]
deg=17
print(translate(p,4,4))
print(rotate(p,deg))
segitiga_3p
Program ini menghitung sisi, sudut, dan luas segitiga yang diberikan tiga titik pada bidang
x,y.
Misalnya, apa yang dimaksud dengan sisi, sudut, dan luas segitiga yang ditentukan oleh
titik (2,4), (10,4), dan (2,10)?
Fungsi triangle_3p() melakukan semua pekerjaan. Lewati tiga titik, masing-masing
sebagai daftar 2-angka, dan itu mengembalikan tiga sisi, tiga sudut dalam derajat yang
berlawanan dengan sisi-sisi itu, dan luasnya. Dalam contoh ini, panjang sisi a, b, dan c kira-kira
6, 8, dan 10 satuan. Besar sudut A, B, dan C yang berhadapan dengan sisi-sisi tersebut kira-kira
10, 36,87, dan 53,13 derajat. Luas segitiga tepat 24 satuan persegi.
from math import *
def triangle_3p(p1,p2,p3):
x1,y1=p1
x2,y2=p2
x3,y3=p3
a=((y2-y1)**2+(x2-x1)**2)**.5
b=((y3-y2)**2+(x3-x2)**2)**.5
c=((y3-y1)**2+(x3-x1)**2)**.5
A=degrees(acos((b*b+c*c-a*a)/b/c/2))
B=degrees(acos((a*a+c*c-b*b)/a/c/2))
C=180-A-B
area=a*b*sin(radians(C))/2
return (a,b,c,A,B,C,area)
p1=[2,10]
p2=[2,4]
p3=[10,4]
tri=triangle_3p(p1,p2,p3)
a,b,c,A,B,C,area=tri
print("p1: ",p1)
print("p2: ",p2)
print("p3: ",p3)
print("a: ",a)
print("b: ",b)
print("c: ",c)
print("A: ",A)
print("B: ",B)
print("C: ",C)
print("area: ",area)
segitiga
Program ini menyelesaikan semua sisi, sudut, dan luas segitiga jika diberikan kombinasi
dari tiga sisi atau sudutnya.
Ada lima kemungkinan kombinasi sisi dan sudut. Jika s mewakili sisi, dan a mewakili
sudut, maka kombinasi yang dapat terjadi saat Anda mengitari sisi dan sudut segitiga secara
berurutan adalah: sss, sas, ssa, asa, dan aas. Program ini menanyakan kondisi mana yang
diketahui, kemudian meminta ketiga bagian tersebut dan menghitung sisanya, ditambah luasnya.
Bagian keluaran diberi label s1, s2, dan s3 untuk sisi-sisinya, dan a1, a2, a3 untuk sudut-
sudut yang berhadapan dengan sisi-sisi tersebut. Area adalah output item terakhir.
Misalnya, berapa sudut dan luas segitiga dengan sisi 4, 5 dan 6?

Masukkan 1 untuk sss pada prompt pertama, lalu masukkan panjang sisinya. Setelah
ketiga bagian dimasukkan, hasilnya dihitung dan ditampilkan:
Di seberang sisi dengan panjang 4 adalah sudut sekitar 41,4 derajat, dan seterusnya. Luas
segitiga sedikit di atas 9,92 satuan persegi.
from math import *
def sss(a,b,c):
C=180-A-B
return [a,b,c,A,B,C]
def sas(a,C,b):
c=(a*a+b*b-2*a*b*cos(radians(C)))**.5
A=degrees(acos((b*b+c*c-a*a)/(2*b*c)))
B=180-A-C
def ssa(b,c,B):
C=degrees(asin(c*sin(radians(B))/b))
A=180-B-C
a=b*sin(radians(A))/sin(radians(B))
def asa(A,c,B):
C=180-A-B
a=c*sin(radians(A))/sin(radians(C))
b=c*sin(radians(B))/sin(radians(C))
def aas(A,C,a):
B=180-A-C
b=a*sin(radians(B))/sin(radians(A))
c=a*sin(radians(C))/sin(radians(A))
# Heron's formula
def area(a,b,c):
p=(a+b+c)/2
return (p*(p-a)*(p-b)*(p-c))**.5
print("1. sss")
print("2. sas")
print("3. ssa")
print("4. asa")
print("5. aas")
n=int(input("? "))
if n<4:
a=input("s: ")
else:
A=input("Ang A: ")
A=float(A) if A else 0
if n==1 or n==3 or n==4:
b=input("s: ")
b=float(b) if b else 0
else:
B=input("Ang B: ")
B=float(B) if B else 0
if n<3 or n==5:
c=input("s: ")
c=float(c) if c else 0
else:
C=input("Ang C: ")
C=float(C) if C else 0
if n==1:
t=sss(a,b,c)
if n==2:
t=sas(a,B,c)
if n==3:
t=ssa(a,b,C)
if n==4:
t=asa(A,b,C)
if n==5:
t=aas(A,B,c)
ar=area(t[0],t[1],t[2])
print("s1: ",t[0])
print("s2: ",t[1])
print("s3: ",t[2])
print("a1: ",t[3])
print("a2: ",t[4])
print("a3: ",t[5])
print("Area: ",ar)
9.
Geometri Luar Angkasa

Bab sebelumnya menyajikan beberapa program untuk bekerja dengan garis, busur,
segitiga, dan konstruksi lainnya dalam bidang dua dimensi. Bab ini memperluas konsep-konsep
tersebut ke dalam tiga dimensi.
Game 3D membutuhkan rotasi di sekitar masing-masing dari tiga sumbu untuk

memindahkan karakter dan objek di luar angkasa. Ada cara ampuh untuk mencapai ini
menggunakan matriks, tetapi bahkan matematika matriks bergantung pada kemampuan untuk
memutar secara matematis di sekitar setiap sumbu. Anda akan menemukan fungsi untuk
melakukan rotasi ini dalam bab ini.
Dalam dua dimensi, satu set tiga titik menentukan segitiga. Ini juga berlaku untuk
himpunan tiga titik spasi. Juga, dalam tiga dimensi, satu set empat titik ruang menentukan
volume seperti tetrahedron. Anda akan menemukan program untuk melakukan perhitungan ini
dalam bab ini.
koordinat_3d
Ada tiga sistem koordinat umum yang digunakan untuk menentukan lokasi titik di ruang
angkasa. Koordinat kartesius menggunakan nilai x,y,z, mirip dengan x,y pada bidang tetapi
diperluas ke ruang angkasa dengan arah az. Koordinat silinder menggunakan jari-jari dan sudut
pada bidang x,y untuk menentukan suatu titik tepat "di bawah" titik tersebut, dan nilai az untuk
jaraknya dari bidang x,y. Koordinat bola menggunakan jarak radial dari titik asal, dan dua sudut
untuk menentukan sudut pada bidang x,y dan sudut menjauhi sumbu z.
Dalam program ini variabel x,y,z mengacu pada jarak sepanjang sumbunya masing-
masing. r dan th (kependekan dari radius dan theta) adalah jari-jari dan sudut untuk koordinat
silinder, dan rh, th, ph (singkatan dari rho, theta, phi) digunakan untuk koordinat bola, di mana
rho adalah jarak dan theta dan phi adalah sudut.
Enam fungsi disediakan, memungkinkan konversi dari salah satu dari tiga sistem koordinat
ke yang lain. Lewati tiga nilai koordinat yang diketahui dan nilai koordinat yang setara akan
dikembalikan dalam daftar. Perhatikan dalam contoh kode sumber bahwa tiga nilai yang
dikembalikan diberikan langsung dari daftar yang dikembalikan ke dalam variabel terpisah. Ini
adalah fitur Python yang sangat bagus, memungkinkan fungsi untuk mengembalikan banyak
nilai secara efektif.
Misalnya, ubah koordinat kartesius 3,4,5 ke sistem koordinat lainnya. Ketika program
dimulai Anda diminta untuk memilih sistem koordinat yang diketahui, dalam hal ini
Cartesian. Seperti yang ditunjukkan, masukkan 1 untuk memilih sistem itu, lalu masukkan 3, 4,
dan 5 seperti yang diminta untuk x, y, dan z.
Setelah memasukkan nilai z akhir, dua nilai ekivalen sistem koordinat lainnya dihitung
dan ditampilkan. Jika Anda perlu merujuk kembali ke nilai yang dimasukkan, cukup gulir ke
atas.
from math import *
def car_to_cyl(x,y,z):
ra=(x*x+y*y)**.5
th=degrees(atan2(y,x))
return[ra,th,z]
def cyl_to_car(ra,th,z):
th=radians(th)
x=ra*cos(th)
y=ra*sin(th)
return [x,y,z]
def car_to_sph(x,y,z):
rh=(x*x+y*y+z*z)**.5
th=degrees(atan2(y,x))
ph=degrees(acos(z/rh))
return [rh,th,ph]
def sph_to_car(rh,th,ph):
th=radians(th)
ph=radians(ph)
x=rh*sin(ph)*cos(th)
y=rh*sin(ph)*sin(th)
z=rh*cos(ph)
return [x,y,z]
def cyl_to_sph(ra,th,z):
rh=(ra*ra+z*z)**.5
ph=degrees(atan2(ra,z))
return [rh,th,ph]
def sph_to_cyl(rh,th,ph):
ph=radians(ph)
ra=rh*sin(ph)
z=rh*cos(ph)
return [ra,th,z]
print("1. car->")
print("2. cyl->")
print("3. sph->")
n=int(input("? "))
if n==1:
x=float(input("x: "))
y=float(input("y: "))
z=float(input("z: "))
ra,th,z=car_to_cyl(x,y,z)
rh,th,ph=car_to_sph(x,y,z)
if n==2:
ra=float(input("ra: "))
th=float(input("th: "))
z=float(input("z: "))
x,y,z=cyl_to_car(ra,th,z)
rh,th,ph=cyl_to_sph(ra,th,z)
if n==3:
rh=float(input("rh: "))
th=float(input("th: "))
ph=float(input("ph: "))
x,y,z=sph_to_car(rh,th,ph)
ra,th,z=sph_to_cyl(rh,th,ph)
print()
print("car")
print("x: ",x)
print("y: ",y)
print("z: ",z)
print()
print("cyl")
print("ra: ",ra)
print("th: ",th)
print("z: ",z)
print()
print("sph")
print("rh: ",rh)
print("th: ",th)
print("ph: ",ph)
putar_3d
Program ini memasukkan titik 3 dimensi dalam ruang dan memutarnya di sekitar masing-
masing dari tiga sumbu dengan beberapa sudut dalam derajat.
Ada tiga fungsi dalam program ini, satu untuk memutar titik ruang di sekitar setiap
sumbu. Untuk mendemonstrasikan fungsi-fungsi ini, titik 3,4,5 diputar di sekitar setiap sumbu
sebesar 45 derajat, dan lokasi baru di setiap kasus adalah output.
Fungsi-fungsi ini merupakan inti dari banyak grafik 3D dan program lainnya. Saya telah
menggunakan fungsi ini untuk memutar antena di Bumi untuk membidik satelit geosinkron, dan
untuk memutar heliostat untuk memantulkan sinar matahari pada target energi matahari.
Untuk melihat semua contoh hasil, pastikan untuk menggulir layar.
from math import *
def rotx(p,a):
x,y,z=p
r=radians(a)
yn=y*cos(r)-z*sin(r)
zn=y*sin(r)+z*cos(r)
return [x,yn,zn]
def roty(p,a):
x,y,z=p
r=radians(a)
xn=z*sin(r)+x*cos(r)
zn=z*cos(r)-x*sin(r)
return [xn,y,zn]
def rotz(p,a):
x,y,z=p
r=radians(a)
xn=x*cos(r)-y*sin(r)
yn=x*sin(r)+y*cos(r)
return [xn,yn,z]
p=[3,4,5]
a=45
print("pt: ",p)
print("deg: ",a)
print()
x,y,z=rotx(p,a)
print("rotx:")
print("x: ",x)
print("y: ",y)
print("z: ",z)
print()
x,y,z=roty(p,a)
print("roty:")
print("x: ",x)
print("y: ",y)
print("z: ",z)
print()
x,y,z=rotz(p,a)
print("rotz:")
print("x: ",x)
print("y: ",y)
print("z: ",z)
segitiga_3d
Program ini menghitung sisi, sudut, dan luas segitiga yang diberikan tiga koordinat ruang.
Misalnya, titik-titik yang diberikan (3,0,5), (4,2,2), dan (0,1,3), tentukan panjang sisi-
sisinya, sudut-sudut yang berhadapan dengan setiap sisinya, dan luas sisinya segi tiga.
Edit nilai untuk ketiga koordinat dalam kode program, dan jalankan untuk melihat sisi dan
sudut segitiga.
a, b, dan c adalah ketiga sisinya, dan A, B, C adalah sudut-sudut, dalam derajat,
berhadapan dengan sisi-sisinya.
from math import *
def triangle_3d(p1,p2,p3):
x1,y1,z1=p1
x2,y2,z2=p2
x3,y3,z3=p3
a=((y2-y1)**2+(x2-x1)**2+(z2-z1)**2)**.5
b=((y3-y2)**2+(x3-x2)**2+(z3-z2)**2)**.5
c=((y3-y1)**2+(x3-x1)**2+(z3-z1)**2)**.5
C=180-A-B
p1=[3,0,5]
p2=[4,2,2]
p3=[0,1,3]
tri=triangle_3d(p1,p2,p3)
print("a: ",a)
print("b: ",b)
print("c: ",c)
print("A: ",A)
print("B: ",B)
print("C: ",C)
volume_4p
Empat titik kartesius dalam ruang menentukan volume, dalam bentuk tetrahedron yang
membentang yang memiliki empat wajah segitiga. Program ini menghitung volume ruang di
dalam gambar ini.
Agar program tetap sederhana, keempat koordinat ruang diatur dalam daftar program, jadi
Anda harus mengedit program untuk menetapkan poin Anda sendiri. Untuk contoh yang
diperlihatkan di sini, titik diatur ke [3,-2,5], [4,4,0], [6,3,7], dan [6,5,0]. Volume terhitung yang
ditentukan oleh titik-titik ini adalah 9,5 unit kubik.
Program ini menggunakan perhitungan matriks untuk mencari volume. Inilah rumusnya,
dan saya mendorong pencarian di Internet untuk mendapatkan pemahaman yang lebih baik
tentang cara kerja matematika matriks ini, dan bagaimana secara umum bekerja dengan matriks
dapat menyederhanakan banyak perhitungan yang menarik.
from math import *
def triangle_3d(p1,p2,p3):
x1,y1,z1=p1
x2,y2,z2=p2
x3,y3,z3=p3
a=((y2-y1)**2+(x2-x1)**2+(z2-z1)**2)**.5
b=((y3-y2)**2+(x3-x2)**2+(z3-z2)**2)**.5
c=((y3-y1)**2+(x3-x1)**2+(z3-z1)**2)**.5
C=180-A-B
p1=[3,0,5]
p2=[4,2,2]
p3=[0,1,3]
tri=triangle_3d(p1,p2,p3)
print("a: ",a)
print("b: ",b)
print("c: ",c)
print("A: ",A)
print("B: ",B)
print("C: ",C)
10.
Ilmu Luar Angkasa
Berapa banyak planet "zona layak huni" yang diperkirakan ada di luar sana, masing-
masing mungkin mampu mendukung kehidupan organik? Seberapa cepat Anda perlu memutar
stasiun luar angkasa untuk menghasilkan efek gravitasi buatan? Seperti apa fase bulan pada hari
Anda dilahirkan?
Ini dan banyak pertanyaan menarik dan menantang lainnya dicakup oleh program dalam
bab ini.
geosync_antena
Satelit mengorbit Bumi dengan periode orbit berdasarkan jaraknya dari Bumi. Stasiun
Luar Angkasa Internasional berjarak sekitar 410 km, dan dibutuhkan sekitar satu setengah jam
untuk menyelesaikan setiap orbit, sedangkan Bulan berjarak sekitar 385.000 km, dan dibutuhkan
sekitar 27 hari untuk menyelesaikan satu orbit.
Satelit geosynchronous mengorbit di antara dua ekstrem ini, pada ketinggian sekitar
35.786 km, di mana setiap orbit memakan waktu tepat satu hari. Mereka terletak di atas
khatulistiwa, mengorbit ke arah yang sama dengan putaran Bumi, sehingga mereka tampak tetap
berada di satu tempat di atas Bumi sepanjang waktu.
Program ini menanyakan lokasi antena di Bumi yang akan diarahkan ke satelit geosinkron
yang terletak pada garis bujur tertentu di atas khatulistiwa, dan menghitung cara
mengarahkannya. Azimuth adalah sudut menjauh dari utara sepanjang cakrawala, di mana timur
adalah 90 derajat, selatan adalah 180 derajat, dan seterusnya. Sudut elevasi naik dari cakrawala,
di mana 90 derajat akan berada tepat di atas kepala.
Tanda bujur harus sesuai dengan lokasi Google Maps. Jadi bujur barat, seperti di seluruh
Amerika Utara, adalah angka negatif, dan satelit dengan lokasi bujur barat juga harus
dimasukkan sebagai angka negatif.
Misalnya, antena yang terletak di Roswell, NM berada di 33,376 derajat utara, dan
104,508 derajat barat. Tujuannya adalah untuk mengarahkannya ke satelit cuaca GOES-15 yang
terletak di 127,8 derajat bujur barat. Edit nilai-nilai ini ke bagian utama program (di bawah
definisi fungsi, di mana kode tidak diindentasi) seperti yang ditunjukkan pada contoh. Antena
harus diarahkan ke barat daya pada 218,0 derajat azimut, dan pada ketinggian 43,8 derajat dari
cakrawala.
Untuk penjelasan lebih rinci tentang matematika yang terlibat dalam perhitungan ini, lihat
dokumen PDF di https://tinyurl.com/y3d5lvng . Untuk daftar satelit geosinkron saat ini,
kunjungi https://tinyurl.com/y2ahfmwe .
from math import *
def geosync(lat,lon,sat_lon):
la=radians(lat)
lo=radians(lon)
sl=radians(sat_lon)
L=sl-lo
D=acos(cos(la)*cos(L))
az=degrees(acos(-tan(la)/tan(D)))
az=az if L>0 else 360-az
cd=cos(D)
el=degrees(atan((cd-1/6.62)/(1-cd*cd)**.5))
az=round(az,2)
el=round(el,2)
return (az,el)
lat=33.376
lon=-104.508
sat_lon=-127.8
az,el=geosync(lat,lon,sat_lon)
print("Ant az: ",az)
print("Ant el: ",el)
bulan
Menghitung Bulan dan fase saat ini dengan akurasi tinggi sangat rumit. Program ini
memberikan perkiraan yang sangat disederhanakan yang cukup akurat untuk sebagian besar
tujuan normal. Tanggal apa pun di tahun 1582 hingga 4000 dapat dimasukkan, dan persentase
yang dinyalakan dari Matahari adalah keluaran, ditambah indikasi "waxing" atau "waning" untuk
memberi tahu Anda di paruh bulan mana Bulan berada.
Misalnya, gambarkan penampakan Bulan dari Bumi pada hari Orville dan Wilbur pertama
kali menerbangkan pesawat mereka, 17 Desember 1903.
Bulan sedang menuju bulan baru (menghilang) dan itu tidak lebih dari sebuah "kuku".
from math import *
def moon(m,d,y):
j=jd(m,d,y)
n=(j+5.367)/29.53058
x=n-int(n)
p=round(int(abs(2*(x)-1)*100))
w=int(2*x)
return [p,w]
def jd(m,d,y):
if m<3:
y-=1
m+=12
a=int(y/100)
b=2-a+int(a/4)
e=int(365.25*(y+4716))
f=int(30.6001*(m+1))

y=int(input("Year (1582-4000): "))
pct,wax=moon(m,d,y)
use_buffer()
set_color(0,0,0)
fill_rect(0,0,317,211)
n=60
for yi in range(-n,n):
y1=yi/n
x2=(1-y1*y1)**.5
x1=-x2
if wax:
xa=x2-(x2-x1)*pct/100
xb=x2
else:
xa=x1
xb=x1+(x2-x1)*pct/100
xp=int(80*xa+160)
yp=int(80*y1+105)
xn=int(80*xb+160)
set_color(255,255,255)
draw_line(xp,yp,xn,yp)
set_color(255,255,0)
s="{}/{}/{} ... the moon is wa{}ing"
if wax:
s=s.format(m,d,y,"x")
else:
s=s.format(m,d,y,"n")
draw_text(60,208,s)
paint_buffer()
uang receh
Program ini sedikit berbeda, karena tidak ada upaya yang dilakukan untuk meminimalkan
jumlah byte dalam kode sumber. Itu juga menghitung sesuatu yang benar-benar menakjubkan,
jadi memasukkan banyak baris komentar penjelasan dan nama variabel yang sangat jelas dan
agak panjang terasa seperti hal yang benar untuk dilakukan. Jika Anda merasa hasilnya terlalu
aneh untuk dipercaya, silakan periksa dua kali dan tiga kali perhitungan saya, dan beri tahu saya
apa yang Anda temukan!
Angkasa adalah tempat yang sangat besar. Sangat besar. Saya telah meneliti dan
menemukan angka terbaru untuk beberapa faktor penting tentang bintang, galaksi, dan
sebagainya, dan meletakkan tautan referensi ke tempat-tempat di Internet di mana Anda dapat
meneliti sendiri. Pada saat Anda membaca ini, beberapa parameter ini kemungkinan besar telah
diperbarui, jadi silakan sesuaikan program sesuai kebutuhan.
Dimensi yang tepat dari satu sen AS, mari kita hitung ukuran tumpukan yang dapat
ditumpuk begitu banyak. Misalnya, satu juta sen dapat ditumpuk dalam baris dan kolom yang
rapi menjadi massa yang kira-kira seukuran meja atau lemari es. Ingatlah hal itu saat kami
melanjutkan.
Program ini menggunakan perkiraan jumlah bintang per galaksi, jumlah galaksi di Alam
Semesta yang diketahui, jumlah planet yang ditemukan di sekitar bintang, dan seterusnya, untuk
menebak berapa banyak planet "zona layak huni" di luar sana. . Ini mengesampingkan planet
yang mungkin terlalu panas atau terlalu dingin untuk kehidupan seperti yang kita ketahui, tetapi
ternyata ada banyak planet yang "tepat". Beberapa sumber menyebut ini "planet Goldilocks".
Ikuti kalkulasi untuk melihat seberapa besar tumpukan sen jika setiap sen mewakili satu
planet zona layak huni. Jawabannya mengejutkan!
# Pennies_us
# https://tinyurl.com/yenrntau
# Dimensions of U.S. penny
diameter = 0.75 # in
thickness = 0.0598 # in
# cubic inches per stacked penny

rect_vol = diameter * diameter * thickness
# cubic feet for one stacked penny

penny_vol = rect_vol / 1728
# https://tinyurl.com/y6cqbaz5
# One in 2 stars has goldilocks planet
goldilocks_factor = 0.5
# https://tinyurl.com/d245jjz
# Two hundred billion galaxies
galaxies = 2e11
# https://tinyurl.com/yg8bdojy
# 250 billion stars in our average sized galaxy
milky_way_stars = 250e9
# Total stars
stars = galaxies * milky_way_stars
# Total habitable goldilocks planets

habitable_planets = stars * goldilocks_factor
# Cubic feet of pennies if same number

# as habitable planets
cubic_feet_pennies = habitable_planets * penny_vol
# https://tinyurl.com/yfylyms4
# Area of continental United States
us_square_miles = 3_119_884.69
# https://tinyurl.com/ye7xtjad
# Convert area to square feet
us_square_feet = us_square_miles * 5280 * 5280
# Feet height of all those pennies if covering U.S.

height_in_feet = cubic_feet_pennies / us_square_feet
# Convert to miles
height_in_miles = height_in_feet / 5280
# https://tinyurl.com/yk3gap7b
# Also convert to kilometers
height_in_km = height_in_miles / 0.621371
# Output results
m=round(height_in_miles,1)
k=round(height_in_km,1)
print("If every earth-like planet were a")
print("U.S. penny, you could stack them")
print("to cover the total continental U.S.")
print("land area to a height of",m,"miles!")
print("(or",k,"km)")
radioisotop
Kecepatan peluruhan radioaktif dalam sampel sebanding dengan jumlah atom radioaktif
dalam sampel. Inti dari perhitungan yang diperlukan melibatkan persamaan diferensial, yang
dapat Anda baca secara online jika tertarik. Mungkin Anda pernah mendengar tentang
penanggalan karbon-14 dari bahan organik purba? Ini adalah bagaimana mereka melakukan
matematika untuk itu! Tetapi program ini bekerja dengan radioisotop apa pun dengan waktu
paruh yang diketahui. Misalnya, batuan yang kembali dari Bulan yang mengandung isotop
radioaktif memungkinkan perkiraan usianya.
Program ini bekerja dengan empat parameter, aktivitas awal sampel, waktu paruh, waktu
berlalu, dan aktivitas akhir sampel. Anda memasukkan kombinasi apa pun dari tiga parameter ini
dan yang keempat dihitung.
Misalnya, sebuah isotop kromium dengan waktu paruh 667,2 jam memiliki aktivitas awal
200 mikrokuri. Apa aktivitasnya tepat 24 jam kemudian?
Perhatikan bahwa waktu paruh mungkin dalam satuan detik, jam, atau bahkan
tahun. Pastikan untuk memasukkan waktu yang telah berlalu dalam unit yang sama dan
cocok. Dalam hal ini kedua nilai dalam jam.
Kegiatan terakhir, diukur pada hari berikutnya, akan menjadi 195 mikrokuri.
from math import *
print("Enter 3 known values...")

s1="Starting activity: "
s2="Half life: "
s3="Elapsed time: "
s4="Final activity: "
sa=input(s1)
sa=float(sa) if sa else 0
ha=input(s2)
ha=float(ha) if ha else 0
et=input(s3)
et=float(et) if et else 0
fa=input(s4)
fa=float(fa) if fa else 0
if not sa:
sa=fa/.5**(et/ha)
if not ha:
ha=et*log(.5)/log(fa/sa)
if not et:
et=ha*log(fa/sa)/log(.5)
if not fa:
fa=sa*.5**(et/ha)
print(" ")
print(s1,sa)
print(s2,ha)
print(s3,et)
print(s4,fa)
relativitas
Pada kecepatan yang sangat tinggi, apa yang disebut kecepatan relativistik, ruang dan
waktu mulai menjadi sangat aneh. Kami tidak melihat efeknya secara normal, karena bahkan
pesawat ruang angkasa tercepat yang kami miliki bergerak hanya dengan sebagian kecil dari
kecepatan cahaya. Jika mereka bisa bergerak dengan kecepatan cahaya, mereka akan mengorbit
Bumi tujuh kali setiap detik.
Inti dari beberapa perhitungan relativistik adalah gamma, nilai yang dihitung dari
kecepatan V dibandingkan dengan kecepatan cahaya C. Berikut rumus gamma:
Program ini memungkinkan Anda memasukkan kecepatan sebagai sebagian kecil dari
kecepatan cahaya. Kecepatan aktual dan nilai gamma kemudian dihitung, dan distorsi waktu,
panjang dan massa dijelaskan. Misalnya, jika sebuah pesawat ruang angkasa dapat melakukan
perjalanan dengan kecepatan 95% dari kecepatan cahaya, inilah yang akan kita amati dari Bumi:
# Relativity
print("Fraction of speed of light")
f=float(input("? "))
g=1/(1-f**2)**.5
c=299792.458
v=c*f
print("v/c: ",f)
print("v (km/s): ",round(v,3))
print("c (km/s): ",c)
print("gamma: ",round(g,5))
print("For 'on-board' time and")
print("length as observed from")
print("Earth, divide by gamma.")
print("For mass, multiply by gamma.")
space_angle
Berapa sudut antara dua bintang di langit? Berapakah kecepatan sudut Stasiun Luar
Angkasa Internasional saat melintas tepat di atas kepala? Ternyata ada banyak alasan untuk
menghitung sudut antara dua arah ruang yang dinyatakan dalam azimuth dan elevasi (atau
kenaikan dan deklinasi kanan, atau garis lintang dan garis bujur dalam hal ini).
Sangat mudah untuk menemukan sudut antara dua arah di pesawat, tetapi menjadi rumit
ketika dimensi ketiga ditambahkan. Saat sudut elevasi meningkat menuju zenith (titik lurus ke
atas) jarak antara sudut azimuth berkurang. Garis azimuth semakin rapat saat Anda melihat lebih
tinggi, hingga menyatu di puncaknya. Matematika dalam program ini menangani komplikasi ini
dengan baik, sehingga sudut antara dua bintang dihitung sama apakah mereka terletak dekat
dengan cakrawala pada suatu malam, atau lebih tinggi di langit pada malam berikutnya.
Misalnya, puncak satu gunung diukur oleh pengamat berada pada azimuth 121,5 derajat
dan ketinggian 18,7 derajat. Dari lokasi yang sama puncak gunung kedua berada pada azimuth
173,4 derajat dan ketinggian 9,1 derajat. Berapakah sudut antara kedua puncak gunung
tersebut? Edit nilai-nilai ini ke dalam program, seperti yang ditunjukkan pada kode di bawah ini,
dan Anda akan menemukan jawabannya adalah sekitar 51,1 derajat.
Perhatikan bahwa ada beberapa fungsi berguna yang didefinisikan dalam program ini,
sebagian besar berkaitan dengan matematika vektor. Program vektor di bagian lain buku ini
menyediakan lebih banyak lagi.
from math import *
def dot(v1, v2):

tx=v1[0]*v2[0]
ty=v1[1]*v2[1]
tz=v1[2]*v2[2]
return tx+ty+tz
def mag(v):
return (v[0]**2+v[1]**2+v[2]**2)**.5
def ang(v1, v2):

d=dot(v1,v2)
m1=mag(v1)
m2=mag(v2)
return degrees(acos(d/m1/m2))
def ae_to_v(az,el):
az=radians(az)
el=radians(el)
z=sin(el)
y=cos(el)*cos(az)
x=cos(el)*sin(az)
return (x,y,z)
def ae_angle(a1,e1,a2,e2):
v1=ae_to_v(a1,e1)
v2=ae_to_v(a2,e2)
return ang(v1,v2)
a1,e1=121.5,18.7
a2,e2=173.4,9.1
print(ae_angle(a1,e1,a2,e2))
stasiun_gravitasi
Dalam film Interstellar, karakter utama memulai stasiun berbentuk roda mereka berputar
di ruang angkasa untuk menghasilkan gravitasi buatan satu G, atau percepatan yang sama seperti
yang kita alami di Bumi dari gravitasi. Mereka berputar hingga kecepatan rotasi tertentu agar
gaya sentrifugal mencapai satu G.
Jadi seberapa cepat mereka perlu memutar stasiun mereka? Tiga faktor tersebut adalah
kecepatan putaran, jari-jari rotasi, dan gaya G yang dihasilkan pada keliling. Program ini
memungkinkan Anda memasukkan dua di antaranya, dan yang ketiga dihitung.
Cari "gravitasi buatan" di Wikipedia untuk penjelasan yang lebih mendalam tentang
bagaimana semua ini bekerja. Jika g adalah jumlah Gs, r adalah jari-jari putaran, dan s adalah
jumlah detik untuk satu putaran penuh, maka inilah rumus yang mengikat semuanya:
Misalnya, saya menghitung waktu rotasi stasiun yang ditampilkan di Interstellar dengan
stopwatch. Itu berputar sekitar 12 detik per putaran penuh. Karakter utama menyatakan bahwa
mereka saat itu berada di satu G, jadi seberapa jauh mereka dari pusat rotasi?
Cukup tekan [enter] ketika diminta untuk yang tidak diketahui, dalam hal ini
Radius. Masukkan dua nilai lainnya seperti yang ditunjukkan, dan program menunjukkan radius
sekitar 36 meter.
from math import *
print("Radius of rotation (meters)")

print("Seconds per rotation")
print("Gs = normal gravity is 1.0")
print("Enter two knowns..")
a="Radius: "
b="Seconds/rot: "
c="Gs of accel: "
r=input(a)
s=input(b)
s=float(s) if s else 0
g=input(c)
g=float(g) if g else 0
if not r:
r=9.8*g*s**2/(4*pi**2)
if not s:
s=2*pi/(9.8*g/r)**.5
if not g:
g=4*pi*pi*r/9.8/s**2
print(a,r)
print(b,s)
print(c,g)
sun_elev
Program ini menyediakan cara sederhana bagi Anda untuk mengukur sudut elevasi
Matahari. Gunakan meteran atau yard stick dan ukur bayangannya pada permukaan yang
datar. Masukkan angka dan sudut elevasi dihitung menggunakan fungsi atan() dalam modul
matematika.
Pastikan untuk menggunakan satuan yang sama untuk tinggi objek dan panjang
bayangan. Misalnya, jika bayangan tongkat meter adalah 134 cm (1 meter adalah 100 cm) maka
sudut elevasi Matahari adalah sekitar 36,7 derajat.
Fungsi atan(), seperti fungsi trigonometri lainnya dalam modul matematika,

mengasumsikan semua sudut dalam radian. Fungsi derajat() digunakan untuk mengubah sudut
elevasi radian menjadi derajat.
from math import *
h=float(input("Height of object: "))

s=float(input("Length of its shadow: "))
elev=degrees(atan(h/s))
print("Sun elevation: ",round(elev,1))
sun_loc
Program ini menghitung lokasi yang tepat di Bumi di mana Matahari berada tepat di atas
kepala di puncaknya. Matahari selalu bersinar di suatu tempat, jadi tempat ini terus-menerus
mengembara mengelilingi planet ini setiap 24 jam, meskipun menempuh jalur yang sedikit
berbeda setiap hari.
Untuk mendemonstrasikan fungsi sunloc(), tanggal dan waktu yang tepat, termasuk offset
zona waktu dari Greenwich, diteruskan ke fungsi dalam daftar. Lintang dan bujur titik zenith
Matahari di Bumi dikembalikan dalam daftar. Keakuratan posisi Matahari menggunakan
algoritma ini berada dalam jarak sekitar 0,01 derajat dari lokasi sebenarnya.
Misalnya, pada 4 Juli 2022 pukul 12:50:00 di Denver, CO (zona waktu offset -6 jam dari
Greenwich) Matahari akan terletak di sekitar 22,82 derajat lintang utara dan 101,37 derajat bujur
barat. Pemeriksaan cepat di Google Maps menunjukkan tempat ini berada di tengah Meksiko,
tepat di utara San Luis Potosi.
from math import *
def sunloc(when):
ye,mo,da,ho,mi,se,tz=when
ta=pi*2
ut=ho-tz+mi/60+se/3600
t=367*ye-7*(ye+(mo+9)//12)//4
dn=t+275*mo//9+da-730531.5+ut/24
sl=dn*0.01720279239+4.894967873
sa=dn*0.01720197034+6.240040768
t=sl+0.03342305518*sin(sa)
ec=t+0.0003490658504*sin(2*sa)
ob=0.4090877234-0.000000006981317008*dn
st=4.894961213+6.300388099*dn
ra=atan2(cos(ob)*sin(ec),cos(ec))
de=asin(sin(ob)*sin(ec))
la=degrees(de)
lo= degrees(ra-st)%360
lo=lo-360 if lo>180 else lo
return [la,lo]
when=[2022,7,4,12,50,0,-6]
la,lo=sunloc(when)
print("When: ",when)
print("Sun lat: ",la)
print("Sun lon: ",lo)
Tentang Penulis
John Clark Craig telah menulis banyak buku tentang topik pemrograman, sebagian besar
mencakup versi bahasa BASIC dan Visual Basic seiring berkembangnya waktu.
Hari ini fokusnya adalah pada Python, bahasa paling populer dan mudah dipelajari di
dunia, cocok untuk memperkenalkan anak muda pada pemrograman untuk pertama kalinya,
namun cukup kuat untuk teknik, desain web, game, robot, dan pembelajaran mesin yang paling
menantang. .. sebenarnya SEMUA area pemrograman panas hari ini.
Selain menulis buku, proyek perangkat lunak John telah mengendalikan dan memantau
proyek energi surya besar, membantu insinyur angin merancang menara yang lebih baik untuk
turbin angin, memantau proyek gas dan minyak alam di Alaska, membantu melatih atlet untuk
tim Olimpiade AS, membantu dalam desain suku cadang pengganti lutut buatan, menyediakan
perpustakaan Python untuk desain 3D yang lebih mudah menggunakan OpenSCAD, dan bahkan
menyediakan alat untuk penelitian berbasis ilmiah tentang fenomena UFO.
John tinggal di Colorado, hari ini membantu istrinya dengan perangkat lunak yang
membantunya membantu pemilik rumah menghemat banyak uang dengan memasang panel surya
di atap rumah. (Lihat Solar-Proud.com)
John sangat menyukai bahasa pemrograman Python dan bagaimana bahasa itu dapat
digunakan dalam banyak cara yang berbeda untuk membantu orang lain membuat dunia menjadi
tempat yang lebih baik, satu baris pemrograman dalam satu waktu.
Buku-buku lain
oleh
John Clark Craig
Untuk daftar buku John yang paling lengkap, kunjungi JohnClarkCraig.com dan itu akan
mengarahkan Anda ke halaman penulis John's Amazon.
Buku-buku John mencakup banyak topik pemrograman, sebagian besar tentang Visual
Basic, tetapi baru-baru ini tentang cara menggunakan Python untuk desain dan pencetakan 3D
dengan OpensSCAD, dan cara memprogram teknologi NumWorksTM, TI-Nspire™ CX II dan
kalkulator TI-84.
Untuk Menghubungi Penulis
Mengunjungi
bookstobelievein.com/python
A Books To Believe In Publication

Semua Hak Dilindungi Undang
- Undang Hak Cipta 2021 oleh John Clark Craig
Tidak ada bagian dari buku ini yang boleh direproduksi atau ditransmisikan dalam bentuk apa pun atau dengan cara apa pun,
elektronik atau mekanis, termasuk fotokopi, rekaman, atau dengan sistem penyimpanan dan pengambilan informasi apa pun,
tanpa izin, secara tertulis dari penerbit.
Bangga Diterbitkan di AS oleh
Buku Untuk Dipercaya
publisher@bookstobelievein.com
Telepon: (303) 794-8888
JohnClarkCraig.com
BooksToBelieveIn.com
Edisi Pertama: ISBN: 9798454148089
Dedikasi
Buku ini didedikasikan untuk Jeff Bretz, rekan penulis beberapa buku Microsoft Press
pada masa itu. Saya akan selalu menghargai banyak percakapan yang kami bagikan tentang
sains, matematika, elektronik, komputer, pemrograman, energi alternatif, dan masa depan.
Jeff, minat kami hampir sama, tetapi saya akan selalu menghargai kebijaksanaan,
wawasan, dan bantuan Anda yang luar biasa dalam segala hal teknis.
Beristirahatlah dengan tenang, sahabatku.
Ucapan Terima Kasih
Selalu ada orang-orang di sekitar yang mendorong dan membantu setiap kali seseorang
menerima tantangan seperti menulis buku. Sahabat saya Jeff Bretz selalu punya jawaban ketika
saya meneleponnya untuk mengajukan pertanyaan teknis yang konyol atau rumit. Jeff meninggal
saat saya menulis buku ini, dan saya akan sangat merindukannya.
Istri saya, EJ, dengan latar belakang matematika dan energi surya selalu menjadi inspirasi
dan pendamping terbaik saat tantangan datang. Kami berdua pengusaha, jadi kami berdua
memahami proses mengarungi subjek dan wilayah baru, di mana orang lain tidak akan berani
pergi. EJ, Anda selalu senang bekerja dengan berdampingan saat kita menempa masa depan kita
yang menakjubkan bersama.
Beberapa orang baik di Texas Instruments membantu membuat proyek buku ini menjadi
mungkin. Cara Kugler, khususnya, selalu ada dengan jawaban atas beberapa pertanyaan sulit,
dan saya akan selamanya berterima kasih atas bantuan dan dukungannya yang luar biasa. Steve
DeBauge berperan penting dalam mengatasi masalah teknis yang sangat sulit.
Secara umum, saya bersyukur Texas Instruments telah memahami kekuatan dan pengaruh
Python dalam kalkulator mereka yang dibuat untuk siswa saat ini dan inovator teknis masa
depan.
Daftar isi
Ucapan Terima Kasih
pengantar
Program
1. Tanggal dan Waktu
 kalender
 tanggal
 tanggal_tambah_hari
 julian
 hari_antara_tanggal
 jam
2. Elektronik
 rata_puncak_rms
 menjembatani
 delta_wye
 frekuensi_panjang gelombang
 led_resistor
 ohm_laws
 paralel
 rc_timing
 seri
 zround
3. Game dan Peluang
 deck_of_cards
 dadu
 angka
 fact_comb_perm
 heads_in_a_row
 berburu_arah
 berburu_jarak
 campur aduk
 labirin
 Penyimpanan
 monty_hall
 pi_buffon
 pi_darts
 random_bytes
 kata_perm
4. GPS dan Navigasi
 gps_area
 Danau_Turquoise
 gps_distance
 titik tengah
 navigasikan
5. Uang dan Keuangan
 deposito
 Nilai masa depan
 minat
 bulan
 pembayaran
 Kepala Sekolah
6. Perhitungan Numerik
 bin_dec_hex
 binary_search
 faktor
 fibonacci
 gcd_lcm
 rasio_emas
 newton
 bilangan prima
 kuadrat
 rect_polar
 simultan_eq
 vektor
7. Program Berguna Lainnya
 konkret
 kode_kunci
 laser_jarak
 mil per jam
 rahasia
 bola_basah
 angin dingin
8. Geometri Bidang
 arc_parts
 area_3p
 area_3s
 area_pts
 lingkaran
 jarak
 bagi_baris
 baris_2p
 line_pt_slope
 mengubah
 segitiga_3p
 segitiga
9. Geometri Luar Angkasa
 koordinat_3d
 putar_3d
 segitiga_3d
 volume_4p
10. Ilmu Luar Angkasa
 geosync_antena
 bulan
 uang receh
 radioisotop
 relativitas
 space_angle
 stasiun_gravitasi
 sun_elev
 sun_loc
tentang Penulis
Buku Lain Oleh John Clark Craig

Python Untuk TI

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Python Untuk TI

Diunggah oleh

Hak Cipta:

Format Tersedia

Python untuk TI-Nspire™

Cara terbaik untuk memanfaatkan Python di kalkulator Anda adalah dengan

Belajar dengan Contoh

Tanggal dan Waktu

# Get month and year

# Month, Year caption

# Days of the week

m=int(input("Month (1-12): "))

m=int(input("Month (1-12): "))

Kode contoh memasukkan tanggal dan menampilkan Nomor Hari Julian. Selanjutnya,

from math import *

m=int(input("Month (1-12): "))

Kalkulator teknologi TI-Nspire™ CX II Anda mampu menampilkan beberapa grafik

Perhatikan baik-baik panggilan fungsi use_buffer(), paint_buffer(), dan clear(). Ini secara

# Rotate a point by a degrees

# Initialize clock face

# Until escape key

# Draw face and numbers

# Draw second marks

# Update the display

print("\n\nInput one AC voltage type\n")

Berikut persamaan yang menghubungkan keempat resistor tersebut:

print("\nDelta to Wye (R or Z)")

Spektrum elektromagnetik mencakup berbagai fenomena, seperti gelombang radio, sinar-

Vs=float(input("Source Vs: "))

Persamaan pertama menyatakan bahwa tegangan (gaya elektromagnetik) sama dengan

Program ini mendefinisikan fungsi bernama ohms_laws(), mencetak beberapa instruksi

Resistansi setara (atau impedansi) dihitung dengan rumus berikut:

Program mendefinisikan fungsi bernama parallel(), dan mencetak dua baris

Contoh menunjukkan bagaimana tanda kurung siku mendefinisikan daftar.

Misalnya, dimulai dengan V1 pada 0 volt, kemudian menerapkan V2 sebesar 5 volt,

Program mendefinisikan fungsi series(), kemudian mencetak instruksi pengingat untuk

Berikut adalah contoh melewatkan daftar dua impedansi bilangan kompleks. Hasil

Game dan Peluang

j=int(input("How many jokers: "))

n=int(input("Deal how many cards: "))

n=int(input("How many dice: "))

Aturannya cukup sederhana. Angka 1 sampai 9 disusun secara acak dalam kotak 3 x 3,

def red(): set_color(255,0,0)

# Get desired challenge

# Create and shuffle the digits

# Create string layout

# Three middle rows

# Bottom row

# Wait for user

print("\nFlips to get",goal,"heads in a row")

print("Jumble word or phrase?")

# Shuffle the indexes

# Check each cell in index order

from random import *

def red(): set_color(255, 0, 0)

set_window(-.4, 1.4, -.095, 1.05)

Modul acak menyediakan beberapa jenis nomor pseudorandom. Program ini memanggil

GPS dan Navigasi

Inilah fungsi gps_points() setelah mengedit koordinat ini ke tempatnya.

Algoritme menggunakan beberapa fungsi trigonometri, sehingga modul matematika

from math import *

#Arch to Golden Gate Bridge

# Distance and bearing

Uang dan Keuangan

Nilai masa depan

dp=float(input("Monthly deposit: "))

Contoh menunjukkan tingkat persentase tahunan sebesar 10,49% dibebankan untuk