Tutorial Python untuk bukan pengatur cara/Contoh Fungsi Lanjutan

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)
    value = a + baki
    return value

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.

---

RUN 2

What happens next?

The variable a gets the value 3 assigned to it and the variable b gets the value 2 assigned to it.

---

And then?

The line if b == 0: is run. Since b has the value 2 this is false so the line return 0 is skipped.

---

And what then?

The line rest = mult(a, b - 1) is run. This line sets the local variable rest to the value of mult(a, b - 1). The value of a is 3 and the value of b is 2 so the function call is mult(3,1)

---

So what is the value of mult(3, 1) ?

We will need to run the function mult with the parameters 3 and 1.

---

RUN 3

So what happens next?

The local variables in the new run of the function are set so that a has the value 3 and b has the value 1. Since these are local values these do not affect the previous values of a and b.

---

And then?

Since b has the value 1 the if statement is false, so the next line becomes rest = mult(a, b - 1).

---

What does this line do?

This line will assign the value of mult(3, 0) to rest.

---

So what is that value?

We will have to run the function one more time to find that out. This time a has the value 3 and b has the value 0.

---

So what happens next?

The first line in the function to run is if b == 0:. b has the value 0 so the next line to run is return 0

---

And what does the line return 0 do?

This line returns the value 0 out of the function.

---

So?

So now we know that mult(3, 0) has the value 0. Now we know what the line rest = mult(a, b - 1) did since we have run the function mult with the parameters 3 and 0. We have finished running mult(3, 0) and are now back to running mult(3, 1). The variable rest gets assigned the value 0.

---

What line is run next?

The line value = a + rest is run next. In this run of the function, a = 3 and rest = 0 so now value = 3.

---

What happens next?

The line return value is run. This returns 3 from the function. This also exits from the run of the function mult(3, 1). After return is called, we go back to running mult(3, 2).

---

Where were we in mult(3, 2)?

We had the variables a = 3 and b = 2 and were examining the line rest = mult(a, b - 1).

---

So what happens now?

The variable rest get 3 assigned to it. The next line value = a + rest sets value to 3 + 3 or 6.

---

So now what happens?

The next line runs, this returns 6 from the function. We are now back to running the line print "3 * 2 = ", mult(3, 2) which can now print out the 6.

---

What is happening overall?

Basically we used two facts to calculate the multiple of the two numbers. The first is that any number times 0 is 0 (x * 0 = 0). The second is that a number times another number is equal to the first number plus the first number times one less than the second number (x * y = x + x * (y - 1)). So what happens is 3 * 2 is first converted into 3 + 3 * 1. Then 3 * 1 is converted into 3 + 3 * 0. Then we know that any number times 0 is 0 so 3 * 0 is 0. Then we can calculate that 3 + 3 * 0 is 3 + 0 which is 3. Now we know what 3 * 1 is so we can calculate that 3 + 3 * 1 is 3 + 3 which is 6.

---

This is how the whole thing works:

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

Should you still have problems with this example, look at the process backwards. What is the last step that happens? We can easily make out that the result of mult(3, 0) is 0. Since b is 0, the function mult(3, 0) will return 0 and stop.

So what does the previous step do? mult(3, 1) does not return 0 because b is not 0. So the next lines are executed: rest = mult (a, b - 1), which is rest = mult (3, 0), which is 0 as we just worked out. So now the variable rest is set to 0.

The next line adds the value of rest to a, and since a is 3 and rest is 0, the result is 3.

Now we know that the function mult(3, 1) returns 3. But we want to know the result of mult(3,2). Therefore, we need to jump back to the start of the program and execute it one more round: mult(3, 2) sets rest to the result of mult(3, 1). We know from the last round that this result is 3. Then value calculates as a + rest, i. e. 3 + 3. Then the result of 3 * 2 is printed as 6.

The point of this example is that the function mult(a, b) starts itself inside itself. It does this until b reaches 0 and then calculates the result as explained above.

Recursion

Programming constructs of this kind are called recursive and probably the most intuitive definition of recursion is:

---

Recursion

If you still don't get it, see recursion.

---

These last two sections were recently written. If you have any comments, found any errors or think I need more/clearer explanations please email. I have been known in the past to make simple things incomprehensible. If the rest of the tutorial has made sense, but this section didn't, it is probably my fault and I would like to know. Thanks.

Contoh

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.

Commented factorial.py

# Another "jump-around" function example:

def factorial(n): # (2.) So once again, this function will REPEAT itself....
    if n <= 1:
        return 1
    return n * factorial(n - 1) # (3.) Because it RE-initiates HERE, and goes back to the top.

print "2! =", factorial(2) # (1.) The "factorial" function is initiated with this line
print "3! =", factorial(3)
print "4! =", factorial(4)
print "5! =", factorial(5)

Commented countdown.py

# Another "jump-around", nice and easy:


def count_down(n): # (2.) Once again, this sequence will repeat itself....
    print n
    if n > 0:
        return count_down(n-1) # (3.) Because it restarts here, and goes back to the top

count_down(5) # (1.) The "count_down" function initiates here