Tutorial Python untuk bukan pengatur cara/Contoh Fungsi Lanjutan

Daripada Wikibooks
Pergi ke pandu arah Pergi ke carian


Ada pembaca yang mendapati bahagian ini berguna dan sebilangan pula akan mendapatinya mengelirukan. Jika anda mendapatinya mengelirukan, tinggalkan (ataupun lihat contoh-contohnya) dahulu. sekarang kita akan membincangkan program berikut satu persatu:

def mult(a, b):
    if b == 0:
        return 0
    baki = mult(a, b - 1)
    nilai = a + baki
    return nilai
print "3 * 2 = ", mult(3, 2)
Output
3 * 2 =  6


Secara amnya program ini mewujudkan satu fungsi darab integer positif (yang lebih perlahan daripada fungsi darab bina dalam) dan kemudian menunjukkan fungsi ini melalui penggunaannya. Atur cara ini menunjukkan penggunaan rekursi, sebuah bentuk lelaran (ulangan) yang menyebabakan fungsi ini memanggil dirinya sendiri sehinggalah sebuah syarat tamat dilunaskan. Ia mengguna tambahan berulang bagi memulangkan keputusan yang sama dengan darab: contoh, 3 + 3 (tambah) memberikan keputusan yang sama dengan 3 * 2 (darab)

PELAKSANAAN 1

Soalan: Apakah perkara pertama yang dilakukan atur cara?
Jawapan: Perkara pertama yang dilakukan adalah fungsi "mult" diberi definisi dengan semua baris melainkan baris yang terakhir.
definisi fungsi mult
def mult(a, b):
    if b == 0:
        return 0
    baki = mult(a, b - 1)
    nilai = a + baki
    return nilai
Ini mewujudkan sebuah fungsi yang mengambil dua parameter dan memulangkan nilai apabila ia selesai. Fungsi ini dapat dilaksanakan kemudian.

Apa yang jadi kemudian?
Baris selepas fungsi, print "3 * 2 = ", mult(3, 2) dilaksanakan.

Dan apa yang dilakukannya?
Ia mencetak 3 * 2 = dan memulangkan nilai mult(3, 2)

Dan apa yang dipulangkan mult(3, 2) ?
Kita perlu melihat fungsi mult satu persatu jika kita ingin tahu.

PELAKSANAAN 2

Apa yang berlaku kemudiannya?
Pemboleh ubah a menerima nilai 3 yang diumpukkan kepadanya dan pemboleh ubah b menerima nilai 2.

Kemudian?
Baris if b == 0: dilaksanakan. Oleh sebab b mempunyai nilai 2, ini bermaksud Palsu, jadi baris return 0 dilangkau.

Dan kemudian?
Baris baki = mult(a, b - 1) dilaksanakan. Baris ini menetapkan pemboleh ubah lokal baki kepada nilai mult(a, b - 1). Nilai a adalah 3 dan nilai b adalah 2 jadi panggilan fungsi adalah mult(3,1)

Jadi apa pula nilai mult(3, 1) ?
Kita perlu melaksanakan fungsi mult dengan parameter 3 dan 1.
PELAKSANAAN 2
def mult(3, 2):
    if b == 0:
        return 0
    baki = mult(3, 2 - 1)
    baki = mult(3, 1)
    nilai = 3 + baki
    return nilai



PELAKSANAAN 3

Apa yang berlaku seterusnya?
Pemboleh ubah lokal dalam pelaksanaan baru fungsi ditetapkan agar a memiliki nilai 3 dan b memiliki nilai 1. Memandangkan bahawa ini adalah nilai-nilai lokal, nilai-nilai ini tidak menjejaskan nilai-nilai a dan b sebelum ini.

Kemudian?
Oleh sebab b memiliki nilai 1, kenyataan if menjadi Palsu, jadi baris berikutnya menjadi baki = mult(a, b - 1).

Apa yang dilakukan baris ini?
Baris ini akan mengumpukkan nilai mult(3, 0) kepada baki.

Apakah nilai itu?
Kita perlu melaksanakan kod sekali lagi bagi mendapatkan jawapannya. Kali ini nilai a adalah 3 dan nilai b adalah 0.

Apa yang berlaku seterusnya?
Baris pertama yang dilaksanakan fungsi adalah if b == 0:. b mempunyai nilai 0, jadi baris yang dilaksanakan berikutan ini adalah return 0

Dan pa yang dilakukan baris return 0?
Baris ini memulangkan nilai 0 daripada fungsi.

Jadi?
Jadi sekarang kita tahu yang mult(3, 0) memiliki nilai 0. Sekarang kita tahu apa yang dilakukan rest = mult(a, b - 1) selepas terlaksananya fungsi mult dengan parameter-parameter 3 dan 0. Kita sudah selesai melaksanakan mult(3, 0) dan kini pulang kepada pelaksanaan semula mult(3, 1). Pemboleh ubah rest menerima umpukan nilai 0.

Baris mana yang dilaksanakn selepas ini?
Baris value = a + baki dilaksanakan. Dalam pelaksanaan ini, a = 3 dan baki = 0, jadi sekarang nilai = 3.

Seterusnya?
Baris return nilai dilaksanakan. Ini memulangkan 3 daripada fungs. Ini juga keluar daripada fungsi mult(3, 1). Selepas return dipanggil, kita pulang kembali kepada pelaksanaan mult(3, 2).

Di mana kita dalam mult(3, 2)?
Kita ada pemboleh ubah a = 3 dan b = 2 dan sedang meneliti baris baki = mult(a, b - 1).

Apa yang berlaku kini??
Pemb oleh ubah baki diumpukkan nilai 3. Bari berikutnya value = a + baki menetapkan nilai kepada 3 + 3 atau 6.

Jadi selepas ini apa yang berlaku?
Baris berikutnya dilaksanakan, ini memulangkan 6 daripada fungsi. Kita kini pulang kepada pelaksanaan print "3 * 2 = ", mult(3, 2) yang sekarang boleh mencetak 6.

Apa yang berlaku secara keseluruhan?
Secara asasnya kita mengguna dua fakta untuk mengira gandaan dua nombor. Yang pertama adalah, apa jua nombor yang didarab dengan 0 adalah 0 (x * 0 = 0). Yang kedua adalah sesuatu nombor didarab dengan nombor lain sama dengan nombor pertama ditambah nombor pertama kali sekali kurang dari nombor kedua (x * y = x + x * (y - 1)). Jadi apa yang berlaku adalah 3 * 2 mula-mual diubah menjadi 3 + 3 * 1. Kemudian 3 * 1 diubah kepada 3 + 3 * 0. Kemudian kita tahu bahawa apa jua nombor didarab dengan 0 adalah 0, jadi so 3 * 0 adalah 0. Kemudian kita dapat kira bahawa 3 + 3 * 0 adalah 3 + 0 yang sama dengan 3. Sekarang kita tahu apa makna 3 * 1, jadi kita dapat membuat perkiraan bahawa 3 + 3 * 1 adalah 3 + 3 yang sama dengan 6.

Ini caranya kod bekerja:

3 * 2
3 + 3 * 1
3 + 3 + 3 * 0
3 + 3 + 0
3 + 3
6

Lihat proses ini cara terbalik jika anda masih menemui kesulitan dengan contoh ini. Apakah langkah terakhir yang berlaku? Kita dapat kira bahawa keputusan mult(3, 0) adalah 0. Oleh sebab b adalah 0, fungsi mult(3, 0) akan memulangkan 0 dan berhenti.

Apa pula yang dilakukan langkah sebelumnya? mult(3, 1) tidak memulangkan 0 kerana b bukan 0. Justeru baris-baris berikutnya dilaksanakan: baki = mult (a, b - 1), yang sama dengan rest = mult (3, 0), yang juga sama dengan 0 seperti yang kita kira tadi. Jadi sekarang pemboleh ubah baki ditetapkan sebagai 0.

Baris berikutnya menambah nilai rest kepada a, dan oleh sebab a adalah 3 dan rest adalah 0, keputusannya adalah 3.

Kita tahu bahawa fungsi mult(3, 1) memulangkan 3. Tetapi kita mahu tahu keputusan mult(3,2). Justeru, kita perlu melompat kembali kepada permulaan program dan laksanakannya sekali lagi: mult(3, 2) menetapkan baki kepada keputusan mult(3, 1). Kita tahu daripada pusingan terakhir bahawa keputusan ini adalah 3. Kemudian nilai menghitung a + baki, iaitu 3 + 3. Kemudian keputusan 3 * 2 dicetak sebagai 6.

Pengajaran daripada contoh ini adalah fungsi mult(a, b) memulakan dirinya sendiri dalam dirinya. Fungsi ini melakukan ini sehingga b mencapai 0 dan kemudiannya menghitung keputusan seperti dijelaskan di atas.

Rekursi[sunting]

Binaan pengaturcaraan jenis ini dipanggil rekursi dan mungkin definisi intuitif rekursi adalah:


Rekursi
Jika anda masih tidak faham, lihat rekursi.

Bahagian-bahagian terakhir ini baru ditulis. Jika anda mempunyai ulasan, terjumpa kesilapan, ataupun berfikiran bahawa saya perlu memberi lebih banyak penjalasan atau penjelasan yang lebih terang, sila kirim e-mel. Saya pernah membuat perkara yang senang menjadi rumit dan sukar/tidak dapat difahami. Sekiranya baki tutorial ini jelas tetapi bahagian ini tidak, ia mungkin disebabkan kesilapan saya dan saya ingin tahu. Terima kasih.

Contoh[sunting]

faktorial.py

# mentakrif fungsi yang mengira faktorial

def faktorial(n):
    if n <= 1:
        return 1
    return n * faktorial(n - 1)

print "2! =", faktorial(2)
print "3! =", faktorial(3)
print "4! =", faktorial(4)
print "5! =", faktorial(5)

Output:

2! = 2
3! = 6
4! = 24
5! = 120

kira_detik.py

def kira_detik(n):
    print n
    if n > 0:
        return kira_detik(n-1)

kira_detik(5)

Output:

5
4
3
2
1
0

Ulasan fungsi_menarik.py

# Ulasan di bawah diberi nombor tingkat agar 
# penjelasan kod lebih terang. Sila baca mengikut tingakatan.
# (tingkat 1, contohnya, ada di bawah)


def mult(a, b): # (2.) Fungsi ini akan berulang kerana ...
    if b == 0:
        return 0
    baki = mult(a, b - 1) # (3.)...Apabila sampai ke SINI, jujukan bermula kembali dari atas! 
    value = a + baki
    return value # (4.) justeru, "return value" tidak akan berlaku
                 # sehingga tingkat 3 dilewati program.
print "3 * 2 = ", mult(3, 2) # (1.) Fungsi "mult" berasal di sini
                             

# Peristiwa "return value" di penghujung hanya boleh berlaku
# sebaik sahaja b sama dengan sifar (b mengurang dengan bilangan 1 setiap kali tingkat 3 berlaku).
# Dan hanya pada masa itu baharu perintah "print" dipaparkan.

# Lihatnya sebagai kesan "lompatan". Amnya apa yang anda perlu faham 
# adalah fungsi dimulakan semual 
# DALAM DIRINYA pada tingkat 3. Justeru, jujukan "melompat" 
# ke atas.

Ulasan faktorial.py

# Satu lagi contoh fungsi "lompatan":

def faktorial(n): # (2.) Fungsi ini akan MENGULANGI dirinya...
    if n <= 1:
        return 1
    return n * faktorial(n - 1) # (3.) Kerana ia MENGASAL semula di sini,
                                # dan pulang ke atas.
 
print "2! =", faktorial(2) # (1.) Fungsi "faktorial" berasal dengan baris ini
print "3! =", faktorial(3)
print "4! =", faktorial(4)
print "5! =", faktorial(5)

Ulasan kira_detik.py

# Satu lagi "lompatan", mudah dan ringkas:


def kira_detik(n): # (2.) Jujukan ini mengulangi dirinya...
    print n
    if n > 0:
        return kira_detik(n-1) # (3.) Kerana ia bermula SEMULA di sini, dan pergi ke atas

kira_detik(5) # (1.) Fungsi "kira_detik" berasal di sini