Fungsi Python3
Fungsi ialah segmen kod yang teratur dan boleh diguna semula yang digunakan untuk melaksanakan fungsi tunggal atau berkaitan. Fungsi
boleh meningkatkan modulariti aplikasi dan penggunaan semula kod. Anda sudah tahu bahawa Python menyediakan banyak fungsi terbina dalam, seperti print(). Tetapi anda juga boleh mencipta fungsi anda sendiri, yang dipanggil fungsi yang ditentukan pengguna.
Tentukan fungsi
Anda boleh mentakrifkan fungsi dengan fungsi yang anda mahu, berikut adalah peraturan mudah:
Kod fungsi A blok bermula dengan kata kunci def, diikuti dengan nama pengecam fungsi dan kurungan ().
Sebarang parameter masuk dan pembolehubah bebas mesti diletakkan di antara kurungan dan ruang antara kurungan boleh digunakan untuk menentukan parameter.
Baris pertama fungsi boleh secara pilihan menggunakan docstring - digunakan untuk menyimpan perihalan fungsi.
Kandungan fungsi bermula dengan kolon dan diinden.
kembali [ungkapan] Menamatkan fungsi, secara pilihan mengembalikan nilai kepada pemanggil. Kembali tanpa ungkapan adalah bersamaan dengan mengembalikan Tiada.
Sintaks
Python mentakrifkan fungsi menggunakan kata kunci def, format umum adalah seperti berikut:
def 函数名（参数列表）: 函数体
Secara lalai, nilai parameter dan nama parameter Ia dipadankan dalam susunan yang ditakrifkan dalam pengisytiharan fungsi.
Contoh
Mari kita gunakan fungsi untuk mengeluarkan "Hello World!":
>>> def hello() :
print("Hello World!")
>>> hello()
Hello World!
>>>Untuk aplikasi yang lebih kompleks, bawa pembolehubah parameter dalam fungsi:
#!/usr/bin/python3
# 计算面积函数
def area(width, height):
return width * height
def print_welcome(name):
print("Welcome", name)
print_welcome("php")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h)) Hasil keluaran contoh di atas:
Welcome php width = 4 height = 5 area = 20
Panggilan fungsi
Tentukan fungsi: beri nama fungsi, nyatakan parameter yang terkandung dalam fungsi dan blok kod struktur.
Selepas struktur asas fungsi ini selesai, anda boleh melaksanakannya melalui panggilan fungsi lain atau terus daripada gesaan arahan Python.
Contoh berikut memanggil fungsi printme():
#!/usr/bin/python3
# 定义函数
def printme( str ):
"打印任何传入的字符串"
print (str);
return;
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");Hasil output contoh di atas:
我要调用用户自定义函数! 再次调用同一函数
Melalui parameter mengikut nilai dan lulus parameter melalui rujukan
Dalam Python, semua parameter (pembolehubah) diluluskan melalui rujukan. Jika anda menukar parameter dalam fungsi, parameter asal juga akan ditukar dalam fungsi yang memanggil fungsi ini. Contohnya:
#!/usr/bin/python3
# 可写函数说明
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4]);
print ("函数内取值: ", mylist)
return
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print ("函数外取值: ", mylist)Objek dihantar ke fungsi dan objek untuk menambah kandungan baharu pada penghujungnya menggunakan rujukan yang sama. Oleh itu, output adalah seperti berikut:
函数内取值: [10, 20, 30, [1, 2, 3, 4]] 函数外取值: [10, 20, 30, [1, 2, 3, 4]]
Parameter
Berikut ialah jenis parameter formal yang boleh digunakan semasa memanggil fungsi:
Parameter yang diperlukan
Parameter kata kunci
Parameter lalai
Parameter panjang boleh ubah
Parameter yang diperlukan
Parameter yang diperlukan mesti dihantar ke dalam fungsi dalam susunan yang betul. Kuantiti apabila dipanggil mestilah sama seperti semasa diisytiharkan.
Apabila memanggil fungsi printme(), anda mesti memasukkan parameter, jika tidak ralat sintaks akan berlaku:
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str); return; #调用printme函数 printme();
Hasil output contoh di atas:
Traceback (most recent call last): File "test.py", line 10, in <module> printme(); TypeError: printme() missing 1 required positional argument: 'str'
Parameter kata kunci
Parameter kata kunci berkait rapat dengan panggilan fungsi Panggilan fungsi menggunakan parameter kata kunci untuk menentukan nilai parameter yang diluluskan.
Menggunakan hujah kata kunci membolehkan fungsi dipanggil dalam susunan yang berbeza daripada semasa ia diisytiharkan, kerana penterjemah Python dapat memadankan nama parameter dengan nilai parameter.
Contoh berikut menggunakan nama parameter apabila memanggil function printme():
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str); return; #调用printme函数 printme( str = "php中文网");
Hasil keluaran contoh di atas:
php中文网
Contoh berikut menunjukkan penggunaan parameter fungsi dan tidak perlu digunakan Tentukan urutan:
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print ("名字: ", name);
print ("年龄: ", age);
return;
#调用printinfo函数
printinfo( age=50, name="php" );Hasil keluaran contoh di atas:
名字: php 年龄: 50
Parameter lalai
Apabila memanggil fungsi, jika tiada parameter diluluskan , parameter lalai akan digunakan. Dalam contoh berikut, jika parameter umur tidak diluluskan, nilai lalai digunakan:
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name);
print ("年龄: ", age);
return;
#调用printinfo函数
printinfo( age=50, name="php" );
print ("------------------------")
printinfo( name="php" );Hasil keluaran contoh di atas:
名字: php 年龄: 50 ------------------------ 名字: php 年龄: 35
Parameter panjang boleh ubah
Anda mungkin memerlukan fungsi untuk mengendalikannya Lebih banyak parameter daripada yang diisytiharkan pada asalnya. Parameter ini dipanggil parameter panjang berubah-ubah Tidak seperti dua parameter di atas, ia tidak akan dinamakan apabila diisytiharkan. Sintaks asas adalah seperti berikut:
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]
Nama pembolehubah dengan asterisk (*) akan menyimpan semua parameter pembolehubah yang tidak dinamakan. Jika tiada parameter dinyatakan apabila fungsi dipanggil, ia adalah tuple kosong. Kita juga tidak boleh menghantar pembolehubah yang tidak dinamakan kepada fungsi tersebut. Contoh berikut:
#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return;
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );Hasil keluaran contoh di atas:
输出: 10 输出: 70 60 50
Fungsi tanpa nama
Python menggunakan lambda untuk mencipta fungsi tanpa nama.
Apa yang dipanggil tanpa nama bermakna anda tidak lagi menggunakan bentuk standard pernyataan def untuk mentakrifkan fungsi.
lambda hanyalah ungkapan, dan badan fungsi jauh lebih ringkas daripada def.
Isi badan lambda ialah ungkapan, bukan blok kod. Hanya logik terhad boleh dirangkumkan dalam ungkapan lambda.
Fungsi lambda mempunyai ruang nama sendiri dan tidak boleh mengakses parameter di luar senarai parameternya sendiri atau dalam ruang nama global.
Walaupun fungsi lambda nampaknya hanya boleh menulis satu baris, ia tidak bersamaan dengan fungsi sebaris C atau C++ Tujuan yang terakhir adalah untuk memanggil fungsi kecil tanpa menduduki memori tindanan dan dengan itu meningkatkan kecekapan pelaksanaan.
Sintaks
Sintaks fungsi lambda hanya mengandungi satu pernyataan, seperti berikut:
lambda [arg1 [,arg2,.....argn]]:expression
Contoh berikut:
#!/usr/bin/python3
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))Keputusan keluaran contoh di atas:
相加后的值为 : 30 相加后的值为 : 40
kenyataan pulangan
kembali [ungkapan] Kenyataan digunakan untuk keluar dari fungsi, secara pilihan mengembalikan ungkapan kepada pemanggil. Kenyataan pulangan tanpa nilai parameter mengembalikan Tiada. Contoh sebelumnya tidak menunjukkan cara mengembalikan nilai Contoh berikut menunjukkan penggunaan pernyataan pulangan:
#!/usr/bin/python3
# 可写函数说明
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total;
# 调用sum函数
total = sum( 10, 20 );
print ("函数外 : ", total)Hasil keluaran contoh di atas:
函数内 : 30 函数外 : 30
Skop pembolehubah.
Dalam Python, pembolehubah program tidak boleh diakses dari semua lokasi keizinan akses bergantung pada tempat pembolehubah diberikan nilai.
