Python 3 - ฟังก์ชั่น
ฟังก์ชันคือบล็อกของโค้ดที่จัดระเบียบและใช้ซ้ำได้ซึ่งใช้เพื่อดำเนินการเดียวที่เกี่ยวข้อง ฟังก์ชั่นให้ความเป็นโมดูลาร์ที่ดีขึ้นสำหรับแอปพลิเคชันของคุณและการนำโค้ดกลับมาใช้ใหม่ในระดับสูง
อย่างที่คุณทราบแล้ว Python มีฟังก์ชันในตัวมากมายเช่น print () เป็นต้น แต่คุณยังสามารถสร้างฟังก์ชันของคุณเองได้ ฟังก์ชันเหล่านี้เรียกว่าฟังก์ชันที่ผู้ใช้กำหนดเอง
การกำหนดฟังก์ชัน
คุณสามารถกำหนดฟังก์ชันเพื่อจัดเตรียมฟังก์ชันที่ต้องการได้ กฎง่ายๆในการกำหนดฟังก์ชันใน Python มีดังนี้
บล็อกฟังก์ชันเริ่มต้นด้วยคำสำคัญ def ตามด้วยชื่อฟังก์ชันและวงเล็บ (())
พารามิเตอร์อินพุตหรืออาร์กิวเมนต์ใด ๆ ควรอยู่ในวงเล็บเหล่านี้ คุณยังสามารถกำหนดพารามิเตอร์ภายในวงเล็บเหล่านี้
คำสั่งแรกของการทำงานอาจเป็นคำสั่งตัวเลือก - สตริงเอกสารของฟังก์ชั่นหรือdocstring
บล็อกโค้ดภายในทุกฟังก์ชันเริ่มต้นด้วยเครื่องหมายจุดคู่ (:) และเยื้อง
คำสั่งส่งคืน [นิพจน์] ออกจากฟังก์ชันโดยเลือกที่จะส่งกลับนิพจน์ไปยังผู้เรียก คำสั่ง return ที่ไม่มีอาร์กิวเมนต์เหมือนกับ return None
ไวยากรณ์
def functionname( parameters ):
"function_docstring"
function_suite
return [expression]
ตามค่าเริ่มต้นพารามิเตอร์จะมีลักษณะการทำงานตามตำแหน่งและคุณต้องแจ้งให้ทราบตามลำดับเดียวกันกับที่กำหนดไว้
ตัวอย่าง
ฟังก์ชันต่อไปนี้รับสตริงเป็นพารามิเตอร์อินพุตและพิมพ์บนหน้าจอมาตรฐาน
def printme( str ):
"This prints a passed string into this function"
print (str)
return
เรียกใช้ฟังก์ชัน
การกำหนดฟังก์ชันตั้งชื่อให้ระบุพารามิเตอร์ที่จะรวมอยู่ในฟังก์ชันและจัดโครงสร้างบล็อกของโค้ด
เมื่อสรุปโครงสร้างพื้นฐานของฟังก์ชันแล้วคุณสามารถดำเนินการได้โดยเรียกใช้จากฟังก์ชันอื่นหรือจากพรอมต์ Python โดยตรง ต่อไปนี้เป็นตัวอย่างในการเรียกไฟล์printme() ฟังก์ชัน -
#!/usr/bin/python3
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print (str)
return
# Now you can call printme function
printme("This is first call to the user defined function!")
printme("Again second call to the same function")
เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -
This is first call to the user defined function!
Again second call to the same function
ผ่านการอ้างอิงเทียบกับมูลค่า
พารามิเตอร์ทั้งหมด (อาร์กิวเมนต์) ในภาษา Python จะถูกส่งผ่านโดยการอ้างอิง หมายความว่าถ้าคุณเปลี่ยนสิ่งที่พารามิเตอร์อ้างถึงภายในฟังก์ชันการเปลี่ยนแปลงจะสะท้อนกลับในฟังก์ชันการโทรด้วย ตัวอย่างเช่น -
#!/usr/bin/python3
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
print ("Values inside the function before change: ", mylist)
mylist[2]=50
print ("Values inside the function after change: ", mylist)
return
# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
ที่นี่เรากำลังรักษาการอ้างอิงของวัตถุที่ส่งผ่านและต่อท้ายค่าในวัตถุเดียวกัน ดังนั้นสิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
Values inside the function before change: [10, 20, 30]
Values inside the function after change: [10, 20, 50]
Values outside the function: [10, 20, 50]
มีอีกหนึ่งตัวอย่างที่อาร์กิวเมนต์ถูกส่งผ่านโดยการอ้างอิงและการอ้างอิงถูกเขียนทับภายในฟังก์ชันที่เรียกว่า
#!/usr/bin/python3
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
mylist = [1,2,3,4] # This would assi new reference in mylist
print ("Values inside the function: ", mylist)
return
# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
พารามิเตอร์ mylistอยู่ในพื้นที่ของการเปลี่ยนแปลงฟังก์ชัน การเปลี่ยนรายการของฉันภายในฟังก์ชันจะไม่มีผลกับรายการของฉัน ฟังก์ชั่นนี้ไม่ทำอะไรเลยและในที่สุดสิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
Values inside the function: [1, 2, 3, 4]
Values outside the function: [10, 20, 30]
อาร์กิวเมนต์ของฟังก์ชัน
คุณสามารถเรียกใช้ฟังก์ชันโดยใช้อาร์กิวเมนต์ที่เป็นทางการประเภทต่อไปนี้ -
- อาร์กิวเมนต์ที่จำเป็น
- อาร์กิวเมนต์คำหลัก
- อาร์กิวเมนต์เริ่มต้น
- อาร์กิวเมนต์ที่มีความยาวตัวแปร
อาร์กิวเมนต์ที่จำเป็น
อาร์กิวเมนต์ที่จำเป็นคืออาร์กิวเมนต์ที่ส่งไปยังฟังก์ชันตามลำดับตำแหน่งที่ถูกต้อง ที่นี่จำนวนอาร์กิวเมนต์ในการเรียกใช้ฟังก์ชันควรตรงกับนิยามฟังก์ชันทุกประการ
เพื่อเรียกใช้ฟังก์ชัน printme()คุณต้องส่งอาร์กิวเมนต์เดียวมิฉะนั้นจะทำให้เกิดข้อผิดพลาดทางไวยากรณ์ดังนี้ -
#!/usr/bin/python3
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print (str)
return
# Now you can call printme function
printme()
เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -
Traceback (most recent call last):
File "test.py", line 11, in <module>
printme();
TypeError: printme() takes exactly 1 argument (0 given)
อาร์กิวเมนต์คำหลัก
อาร์กิวเมนต์คำหลักเกี่ยวข้องกับการเรียกใช้ฟังก์ชัน เมื่อคุณใช้อาร์กิวเมนต์คำสำคัญในการเรียกใช้ฟังก์ชันผู้เรียกจะระบุอาร์กิวเมนต์ด้วยชื่อพารามิเตอร์
สิ่งนี้ช่วยให้คุณสามารถข้ามอาร์กิวเมนต์หรือไม่เรียงลำดับได้เนื่องจากตัวแปล Python สามารถใช้คีย์เวิร์ดที่ให้มาเพื่อจับคู่ค่ากับพารามิเตอร์ คุณยังสามารถเรียกใช้คำหลักไปยังไฟล์printme() ฟังก์ชั่นดังต่อไปนี้ -
#!/usr/bin/python3
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print (str)
return
# Now you can call printme function
printme( str = "My string")
เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -
My string
ตัวอย่างต่อไปนี้ให้ภาพที่ชัดเจนขึ้น โปรดทราบว่าลำดับของพารามิเตอร์ไม่สำคัญ
#!/usr/bin/python3
# Function definition is here
def printinfo( name, age ):
"This prints a passed info into this function"
print ("Name: ", name)
print ("Age ", age)
return
# Now you can call printinfo function
printinfo( age = 50, name = "miki" )
เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -
Name: miki
Age 50
อาร์กิวเมนต์เริ่มต้น
อาร์กิวเมนต์เริ่มต้นคืออาร์กิวเมนต์ที่ถือว่าเป็นค่าเริ่มต้นหากไม่มีการระบุค่าในการเรียกใช้ฟังก์ชันสำหรับอาร์กิวเมนต์นั้น ตัวอย่างต่อไปนี้ให้แนวคิดเกี่ยวกับอาร์กิวเมนต์เริ่มต้นซึ่งจะพิมพ์อายุเริ่มต้นหากไม่ผ่าน -
#!/usr/bin/python3
# Function definition is here
def printinfo( name, age = 35 ):
"This prints a passed info into this function"
print ("Name: ", name)
print ("Age ", age)
return
# Now you can call printinfo function
printinfo( age = 50, name = "miki" )
printinfo( name = "miki" )
เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -
Name: miki
Age 50
Name: miki
Age 35
อาร์กิวเมนต์ที่มีความยาวตัวแปร
คุณอาจต้องประมวลผลฟังก์ชันสำหรับอาร์กิวเมนต์มากกว่าที่คุณระบุไว้ในขณะที่กำหนดฟังก์ชัน อาร์กิวเมนต์เหล่านี้เรียกว่าอาร์กิวเมนต์ที่มีความยาวตัวแปรและไม่มีชื่ออยู่ในนิยามฟังก์ชันซึ่งแตกต่างจากอาร์กิวเมนต์ที่จำเป็นและอาร์กิวเมนต์เริ่มต้น
ไวยากรณ์สำหรับฟังก์ชันที่มีอาร์กิวเมนต์ตัวแปรที่ไม่ใช่คีย์เวิร์ดได้รับด้านล่าง -
def functionname([formal_args,] *var_args_tuple ):
"function_docstring"
function_suite
return [expression]
เครื่องหมายดอกจัน (*) วางไว้หน้าชื่อตัวแปรที่เก็บค่าของอาร์กิวเมนต์ตัวแปรที่ไม่ใช่คำหลักทั้งหมด ทูเปิลนี้จะว่างเปล่าหากไม่มีการระบุอาร์กิวเมนต์เพิ่มเติมระหว่างการเรียกใช้ฟังก์ชัน ต่อไปนี้เป็นตัวอย่างง่ายๆ -
#!/usr/bin/python3
# Function definition is here
def printinfo( arg1, *vartuple ):
"This prints a variable passed arguments"
print ("Output is: ")
print (arg1)
for var in vartuple:
print (var)
return
# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )
เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -
Output is:
10
Output is:
70
60
50
ฟังก์ชันที่ไม่ระบุตัวตน
ฟังก์ชันเหล่านี้เรียกว่า anonymous เนื่องจากไม่ได้ประกาศในลักษณะมาตรฐานโดยใช้ defคำสำคัญ. คุณสามารถใช้ไฟล์lambda คำหลักเพื่อสร้างฟังก์ชันที่ไม่ระบุชื่อขนาดเล็ก
รูปแบบแลมบ์ดาสามารถรับอาร์กิวเมนต์จำนวนเท่าใดก็ได้ แต่ส่งคืนค่าเพียงค่าเดียวในรูปแบบของนิพจน์ ไม่สามารถมีคำสั่งหรือหลายนิพจน์
ฟังก์ชันที่ไม่ระบุชื่อไม่สามารถเรียกโดยตรงเพื่อพิมพ์ได้เนื่องจากแลมบ์ดาต้องการนิพจน์
ฟังก์ชันแลมบ์ดามีเนมสเปซโลคัลของตนเองและไม่สามารถเข้าถึงตัวแปรอื่นนอกเหนือจากที่อยู่ในรายการพารามิเตอร์และในเนมสเปซส่วนกลาง
แม้ว่าจะดูเหมือนว่า lambdas เป็นฟังก์ชันเวอร์ชันหนึ่งบรรทัด แต่ก็ไม่เทียบเท่ากับคำสั่งแบบอินไลน์ใน C หรือ C ++ ซึ่งมีจุดประสงค์เพื่อการจัดสรรสแต็กโดยการส่งผ่านฟังก์ชันในระหว่างการเรียกใช้ด้วยเหตุผลด้านประสิทธิภาพ
ไวยากรณ์
ไวยากรณ์ของ lambda ฟังก์ชันมีเพียงคำสั่งเดียวซึ่งมีดังต่อไปนี้ -
lambda [arg1 [,arg2,.....argn]]:expression
ต่อไปนี้เป็นตัวอย่างเพื่อแสดงให้เห็นว่า lambda รูปแบบของฟังก์ชันการทำงาน -
#!/usr/bin/python3
# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2
# Now you can call sum as a function
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))
เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -
Value of total : 30
Value of total : 40
คำชี้แจงการคืนสินค้า
คำสั่งส่งคืน [นิพจน์] ออกจากฟังก์ชันโดยเลือกที่จะส่งกลับนิพจน์ไปยังผู้เรียก คำสั่ง return ที่ไม่มีอาร์กิวเมนต์เหมือนกับ return None
ตัวอย่างทั้งหมดที่ระบุด้านล่างจะไม่ส่งคืนค่าใด ๆ คุณสามารถคืนค่าจากฟังก์ชันได้ดังนี้ -
#!/usr/bin/python3
# Function definition is here
def sum( arg1, arg2 ):
# Add both the parameters and return them."
total = arg1 + arg2
print ("Inside the function : ", total)
return total
# Now you can call sum function
total = sum( 10, 20 )
print ("Outside the function : ", total )
เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -
Inside the function : 30
Outside the function : 30
ขอบเขตของตัวแปร
ตัวแปรทั้งหมดในโปรแกรมอาจไม่สามารถเข้าถึงได้จากทุกตำแหน่งในโปรแกรมนั้น ขึ้นอยู่กับตำแหน่งที่คุณประกาศตัวแปร
ขอบเขตของตัวแปรจะกำหนดส่วนของโปรแกรมที่คุณสามารถเข้าถึงตัวระบุเฉพาะได้ มีขอบเขตพื้นฐานสองประการของตัวแปรใน Python -
- ตัวแปรส่วนกลาง
- ตัวแปรท้องถิ่น
ตัวแปรส่วนกลางเทียบกับท้องถิ่น
ตัวแปรที่กำหนดไว้ภายในเนื้อความของฟังก์ชันมีขอบเขตเฉพาะที่และตัวแปรที่กำหนดไว้ภายนอกมีขอบเขตส่วนกลาง
ซึ่งหมายความว่าตัวแปรโลคัลสามารถเข้าถึงได้เฉพาะภายในฟังก์ชันที่มีการประกาศเท่านั้นในขณะที่ตัวแปรส่วนกลางสามารถเข้าถึงได้ทั่วทั้งเนื้อหาของโปรแกรมโดยฟังก์ชันทั้งหมด เมื่อคุณเรียกใช้ฟังก์ชันตัวแปรที่ประกาศภายในจะถูกนำเข้าสู่ขอบเขต ต่อไปนี้เป็นตัวอย่างง่ายๆ -
#!/usr/bin/python3
total = 0 # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
# Add both the parameters and return them."
total = arg1 + arg2; # Here total is local variable.
print ("Inside the function local total : ", total)
return total
# Now you can call sum function
sum( 10, 20 )
print ("Outside the function global total : ", total )
เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -
Inside the function local total : 30
Outside the function global total : 0