(Python) Subrutin: Prosedur dan Fungsi - 1

Subrutin

Menggunakan subrutin membolehkan anda mengelakkan pertindihan kod, jika anda perlu menulis kod yang sama di tempat yang berbeza dalam program. 
Perpustakaan yang diimport ke dalam program (contohnya, matematik perpustakaan matematik) terdiri daripada subrutin yang telah disusun oleh seseorang. Pengaturcara tidak perlu memikirkan algoritma apa yang mereka laksanakan, tetapi cukup gunakannya, hanya memikirkan apa sebenarnya yang mereka lakukan. Ini adalah penjimat masa yang besar. Tidak perlu menulis algoritma yang telah ditulis oleh orang lain.

Setiap subrutin hanya perlu melakukan satu tugas,  sama ada hanya mengira sesuatu, atau mengeluarkan beberapa data, atau melakukan sesuatu yang lain. 

Terdapat dua jenis subrutin - prosedurdan fungsi.

Sub-prosedur melakukan beberapa tindakan, seperti memaparkan hasil pada skrin dalam bentuk tertentu (contoh mudah, pernyataan print() ialah sub-prosedur standard yang mencetak data ke skrin).

Subrutin fungsi mengembalikan hasil (nombor, rentetan aksara, dll.) yang boleh kita gunakan dalam program utama.

Mari cuba tulis prosedur mudah:
Katakan kita perlu memaparkan rentetan "Ralat" pada skrin setiap kali ralat boleh berlaku dalam kod disebabkan oleh kesalahan pengguna. Contohnya, apabila dia memasukkan data yang salah.
Ini boleh dilakukan dengan menulis pernyataan print("Ralat") Dan sekarang bayangkan bahawa baris sedemikian perlu dimasukkan di banyak tempat dalam program. Sudah tentu, anda boleh menulisnya di mana-mana sahaja. Tetapi penyelesaian ini mempunyai dua kelemahan.
1) Rentetan ini akan disimpan dalam ingatan berkali-kali.
2) Jika kita ingin menukar output pada ralat, kita perlu menukar baris ini sepanjang program, yang agak menyusahkan

Untuk kes sedemikian, prosedur diperlukan.
Program dengan prosedur mungkin kelihatan seperti ini:
  def printError(): # perihalan prosedur print("Ralat") ... printError() # mulakan prosedur untuk pelaksanaan. # Hanya nyatakan nama prosedur yang ingin kami laksanakan ... printError()

Perlu diingat!

1. Prosedur bermula dengan perkataan def (dari bahasa Inggeris - define - to define). Selepas nama prosedur, kurungan kosong dan titik bertindih ditulis . Parameter boleh ditentukan di dalam kurungan (kita akan bercakap tentang perkara ini kemudian).
2. Semua pernyataan yang dilaksanakan dalam prosedur diinden. 
3. Untuk melaksanakan prosedur, dalam atur cara utama anda perlu memanggilnya dengan nama dan ingat untuk menulis kurungan!
4. Anda boleh memanggil prosedur dalam program seberapa banyak kali yang anda suka.

Parameter dan Argumen

Sekarang mari kita bayangkan bahawa kita perlu memaparkan mesej yang berbeza sebagai tindak balas kepada ralat pengguna, bergantung pada jenis kesilapan yang dia lakukan.
Dalam kes ini, anda boleh menulis prosedur anda sendiri untuk setiap ralat:   def printErrorZero(): print("Ralat. Pembahagian dengan sifar!") def printErrorInput(): print("Ralat dalam input!")
Bagaimana jika terdapat banyak lagi kesilapan yang mungkin berlaku? Penyelesaian ini tidak sesuai dengan kami!
Kita perlu belajar cara mengawal prosedur dengan memberitahu mesej ralat yang hendak dipaparkan.
Untuk melakukan ini, kami memerlukan parameter yang akan kami tulis dalam kurungan selepas nama prosedur def printError(s): cetak("s")
Dalam prosedur ini, s ialah parameter - pembolehubah khas yang membolehkan anda mengawal prosedur.
 

Parameter ialah pembolehubah yang menentukan cara subrutin berfungsi. Nama parameter dipisahkan koma dalam pengepala subrutin.

Sekarang, apabila memanggil prosedur, anda perlu menunjukkan dalam kurungan nilai sebenar yang akan diberikan kepada parameter (pembolehubah s) di dalam prosedur kami printError("Ralat! Pembahagian dengan sifar!")
Nilai sedemikian dipanggil argumen.
 

Argumen ialah nilai parameter yang dihantar kepada subrutin apabila ia dipanggil.

Hujah boleh bukan sahaja nilai tetap, tetapi juga pembolehubah atau ungkapan aritmetik.

Pembolehubah tempatan dan global

Anda boleh mengakses pembolehubah global daripada mana-mana subrutin. 

Selalunya perlu memperkenalkan pembolehubah tambahan yang hanya akan digunakan dalam subrutin. Pembolehubah sedemikian dipanggil setempat (atau setempat). Anda boleh bekerja dengan mereka hanya dalam subrutin di mana ia dicipta. Selebihnya rutin tidak "tahu" apa-apa tentang mereka.

Oleh itu, adalah mungkin untuk mengehadkan skop (skop) pembolehubah hanya kepada subrutin di mana ia benar-benar diperlukan. Dalam pengaturcaraan, teknik ini dipanggil enkapsulasi  - menyembunyikan pembolehubah daripada diubah dari luar.

Analisis tiga program:

 

Penerangan	Program
1) Dalam atur cara ini, pembolehubah i ialah setempat. Jika tiada pembolehubah i dalam program utama, maka kita akan mendapat mesej ralat. Dan jika terdapat pembolehubah sedemikian (maka ia adalah pembolehubah global), maka nilainya dipaparkan pada skrin.	ujian def(): cetakan(i)
2) Di sini, walaupun terdapat pembolehubah global i, pembolehubah tempatan baharu i akan dibuat dengan nilai 2 dan 2 akan muncul pada skrin.	ujian def():   i = 2 cetakan(i)
3) Dalam program ini, terdapat pembolehubah global i dengan nilai 15. Nilainya boleh ditukar di dalam subrutin, untuk ini adalah perlu untuk mengisytiharkan secara eksplisit bahawa ia adalah global ( gunakan arahan global ). Prosedur ini akan berfungsi dengan pembolehubah global i dan ia akan diberikan nilai baharu 2. Nilai 2 dipaparkan.	ujian def():   global i i = 2 # program utama i = 15 cetak(i)