Python - ฟังก์ชั่น

ฟังก์ชันคือบล็อกของโค้ดที่จัดระเบียบและใช้ซ้ำได้ซึ่งใช้ในการดำเนินการเดียวที่เกี่ยวข้อง ฟังก์ชั่นให้ความเป็นโมดูลาร์ที่ดีขึ้นสำหรับแอปพลิเคชันของคุณและการนำโค้ดกลับมาใช้ใหม่ในระดับสูง

ดังที่คุณทราบแล้ว 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/python

# 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("I'm first call to user defined function!")
printme("Again second call to the same function")

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

I'm first call to user defined function!
Again second call to the same function

ผ่านการอ้างอิงเทียบกับมูลค่า

พารามิเตอร์ทั้งหมด (อาร์กิวเมนต์) ในภาษา Python จะถูกส่งผ่านโดยการอ้างอิง หมายความว่าถ้าคุณเปลี่ยนสิ่งที่พารามิเตอร์อ้างถึงภายในฟังก์ชันการเปลี่ยนแปลงจะสะท้อนกลับในฟังก์ชันการโทรด้วย ตัวอย่างเช่น -

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   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

ที่นี่เรากำลังรักษาการอ้างอิงของวัตถุที่ส่งผ่านและต่อท้ายค่าในวัตถุเดียวกัน ดังนั้นสิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

มีอีกหนึ่งตัวอย่างที่อาร์กิวเมนต์ถูกส่งผ่านโดยการอ้างอิงและการอ้างอิงถูกเขียนทับภายในฟังก์ชันที่เรียกว่า

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4]; # This would assig 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/python

# 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/python

# 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/python

# 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/python

# 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/python

# 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 คุณสามารถใช้คีย์เวิร์ดแลมบ์ดาเพื่อสร้างฟังก์ชันที่ไม่ระบุตัวตนขนาดเล็ก

• รูปแบบแลมบ์ดาสามารถรับอาร์กิวเมนต์จำนวนเท่าใดก็ได้ แต่ส่งคืนค่าเพียงค่าเดียวในรูปแบบของนิพจน์ ไม่สามารถมีคำสั่งหรือหลายนิพจน์

• ฟังก์ชันที่ไม่ระบุชื่อไม่สามารถเรียกโดยตรงเพื่อพิมพ์ได้เนื่องจากแลมบ์ดาต้องการนิพจน์

• ฟังก์ชันแลมบ์ดามีเนมสเปซโลคัลของตนเองและไม่สามารถเข้าถึงตัวแปรอื่นนอกเหนือจากที่อยู่ในรายการพารามิเตอร์และในเนมสเปซส่วนกลาง

• แม้ว่าแลมบ์ดาจะเป็นฟังก์ชันเวอร์ชันบรรทัดเดียว แต่ก็ไม่เทียบเท่ากับคำสั่งแบบอินไลน์ใน C หรือ C ++ ซึ่งมีจุดประสงค์โดยการส่งผ่านการจัดสรรฟังก์ชันสแต็กระหว่างการเรียกใช้เพื่อเหตุผลด้านประสิทธิภาพ

ไวยากรณ์

ไวยากรณ์ของฟังก์ชันแลมบ์ดามีเพียงคำสั่งเดียวซึ่งมีดังต่อไปนี้ -

lambda [arg1 [,arg2,.....argn]]:expression

ต่อไปนี้เป็นตัวอย่างเพื่อแสดงให้เห็นว่ารูปแบบของฟังก์ชันแลมด้าทำงานอย่างไร -

#!/usr/bin/python

# 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/python

# 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/python

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