ฟังก์ชัน Python ที่สำคัญที่สุด [พร้อมตัวอย่าง] | ประเภทของฟังก์ชัน
เผยแพร่แล้ว: 2020-03-27เมื่อไม่กี่ปีที่ผ่านมา Java เป็นภาษาการเขียนโปรแกรมชั้นนำ โดยมีฐานผู้ใช้มากกว่า 7.6 ล้านคน
อย่างไรก็ตาม วันนี้ Python ได้แซงหน้าจำนวนนี้และเป็นตัวเลือกที่ต้องการของ นักพัฒนา 8.2 ล้านคน !
ความง่ายในการเขียนโปรแกรมและความสามารถในการประหยัดเวลาของ Python ทำให้บริษัทส่วนใหญ่ใช้มันเพื่อวัตถุประสงค์ต่างๆ และเงินเดือนนักพัฒนา python ในอินเดียเป็นเครื่องพิสูจน์
เนื่องจากความต้องการนักพัฒนา Python เพิ่มขึ้น ผู้คนจึงต้องการเรียนรู้วิธีการเขียนโค้ดใน Python และฟังก์ชันต่างๆ ใน Python
ในบทความนี้ เราจะเน้นไปที่ฟังก์ชัน Python ต่างๆ และวิธีการเขียนโค้ดโดยใช้ฟังก์ชันเหล่านี้
แต่ก่อนอื่นมาทำความเข้าใจ…
สารบัญ
ฟังก์ชั่นใน Python คืออะไร?
ชุดคำสั่งที่รับอินพุตและดำเนินการคำนวณเฉพาะเพื่อให้เอาต์พุตเรียกว่าฟังก์ชัน
ซึ่งช่วยขจัดความจำเป็นในการเขียนโค้ดเดียวกันซ้ำแล้วซ้ำอีก เนื่องจากคุณสามารถเรียกใช้ฟังก์ชันเพื่อรับเอาต์พุตสำหรับอินพุตต่างๆ ได้
มันบอกอะไรคุณ?
Python ช่วยควบคุมขนาดของโปรแกรมและทำให้จัดการได้ง่ายขึ้น ดังนั้นจึงหลีกเลี่ยงการทำซ้ำ
Python มีรายการฟังก์ชันในตัวอยู่แล้ว รวมถึง print()
ไวยากรณ์ของฟังก์ชัน Python
ไวยากรณ์ทั่วไปของฟังก์ชัน Python มีลักษณะดังนี้:
def function_name (รายการพารามิเตอร์):
คำสั่ง กล่าวคือ ตัวฟังก์ชัน
ศัพท์แสงนี้หมายความว่าอย่างไร
- def หมายถึงการเริ่มต้นของส่วนหัวของฟังก์ชัน
- ชื่อฟังก์ชันคือชื่อที่กำหนดให้กับฟังก์ชันเพื่อระบุ
- รายการพารามิเตอร์มีขึ้นเพื่อส่งผ่านค่าไปยังฟังก์ชัน
- เครื่องหมายทวิภาคระบุจุดสิ้นสุดของส่วนหัวของฟังก์ชัน
- คำสั่ง (อย่างน้อยหนึ่งรายการ) กำหนดเนื้อหาของฟังก์ชัน
การเรียกใช้ฟังก์ชัน Python
การเรียกใช้ฟังก์ชันใน Python นั้นค่อนข้างง่าย
เพียงใช้ชื่อฟังก์ชันหลังวงเล็บ
ตัวอย่าง:
def my_function():
พิมพ์("สวัสดีจาก upGrad!")
my_function()
เอาท์พุท:
สวัสดีจาก upGrad!
ในสิ่งนี้ เมื่อคุณเรียกใช้ฟังก์ชัน คุณได้รับคำสั่งที่คุณป้อนในฟังก์ชันการพิมพ์
ค่อนข้างง่ายใช่มั้ย
อาร์กิวเมนต์ใน Python
ข้อมูลทั้งหมดที่ส่งผ่านไปยังฟังก์ชันจะทำผ่านอาร์กิวเมนต์
คุณกำหนดอาร์กิวเมนต์ภายในวงเล็บหลังชื่อของฟังก์ชัน
ตราบใดที่คุณแยกอาร์กิวเมนต์ทั้งหมดด้วยเครื่องหมายจุลภาค คุณสามารถสร้างได้มากเท่าที่คุณต้องการ
นี่คือตัวอย่างที่มีฟังก์ชันที่มีหนึ่งอาร์กิวเมนต์
ในนี้ คุณขอให้ผู้ใช้ป้อนชื่อเมืองและพิมพ์ด้วยชื่อประเทศ
ตัวอย่าง:
def my_function( ชื่อเมือง ):
พิมพ์ (ชื่อเมือง + “, อินเดีย”)
my_function(“เดลี”)
my_function("มุมไบ")
my_function(“เจนไน”)
เอาท์พุท:
เดลี อินเดีย
มุมไบ อินเดีย
เจนไน อินเดีย
ตอนนี้ มาดูกันว่าจะเกิดอะไรขึ้นเมื่อคุณใช้สองอาร์กิวเมนต์และคั่นด้วยเครื่องหมายจุลภาค
ตัวอย่าง:
def my_function(ชื่อเมือง ชื่อประเทศ):
พิมพ์ (ชื่อเมือง + “, ” + ชื่อประเทศ)
my_function("ลัคเนา", "อินเดีย")
เอาท์พุท:
ลัคเนา ประเทศอินเดีย
โปรดทราบว่าหากคุณกำหนดสองอาร์กิวเมนต์ในฟังก์ชัน คุณต้องเรียกอาร์กิวเมนต์ด้วยสองอาร์กิวเมนต์ มิฉะนั้น จะทำให้เกิดข้อผิดพลาด:
Traceback (การโทรล่าสุดล่าสุด):
ไฟล์ “./prog.py” บรรทัดที่ 4 ใน <module>
TypeError: my_function() ไม่มีอาร์กิวเมนต์ตำแหน่งที่ต้องการ 1 รายการ: 'ชื่อประเทศ'
ส่งคืนค่าใน Python
หาก ต้องการให้ฟังก์ชันคืนค่า ให้ใช้ คำสั่ง return
ตัวอย่าง:
def my_function(x):
ผลตอบแทน 7 + x
พิมพ์(my_function(3))
พิมพ์(my_function(8))
พิมพ์(my_function(10))
เอาท์พุท:
10
15
17
อาร์กิวเมนต์ตามอำเภอใจใน Python
สิ่งเหล่านี้มีประโยชน์มากที่สุดเมื่อคุณไม่ทราบว่าจะต้องส่งผ่านอาร์กิวเมนต์จำนวนเท่าใดไปยังฟังก์ชัน
ในกรณีเช่นนี้ จำเป็นต้องใช้ดอกจัน (*) ก่อนชื่อของพารามิเตอร์
ตัวอย่าง:
def ทักทาย (* ชื่อ):
# ชื่อเป็นทูเพิลที่มีอาร์กิวเมนต์
สำหรับชื่อในชื่อ:
พิมพ์ (“สวัสดี” ชื่อ)
ทักทาย (“ทอม”,”เอ็ด”,”แฮร์รี่”)
เอาท์พุท:
สวัสดีคุณตั้ม
สวัสดี เอ็ด
สวัสดีแฮร์รี่
อาร์กิวเมนต์คำหลักใน Python
อาร์กิวเมนต์ของคำหลักถูกสร้างขึ้นเมื่อไม่มีลำดับที่ต้องการ
ตัวอย่าง:
def my_function(song3, song1, song2):
พิมพ์ (“เพลงโปรดของฉันคือ ” + เพลง2)
my_function(song1 = “โบฮีเมียนแรปโซดี”, song2 = “เหนือเสียง”, เพลง3 = “เลียนแบบ”)
เอาท์พุท:
เพลงโปรดของฉันคือ Supersonic
อาร์กิวเมนต์เริ่มต้นใน Python
อาร์กิวเมนต์เหล่านี้เป็นอาร์กิวเมนต์ที่ใช้ค่าเริ่มต้นในฟังก์ชันเมื่อไม่มีค่าที่ระบุ
ตัวอย่าง:
def my_function( โรค = “โควิด-19”):
พิมพ์(โรค + ” เป็นโรคติดต่อ”)
my_function("อีโบลา")
my_function("ไข้หวัดใหญ่")
my_function()
my_function (“โรคหัด”)

เอาท์พุท:
อีโบลาเป็นโรคติดต่อ
ไข้หวัดใหญ่เป็นโรคติดต่อ
โควิด 19 เป็นโรคติดต่อ
โรคหัดเป็นโรคติดต่อ
ฟังก์ชันนิรนามใน Python
ฟังก์ชันที่ไม่ได้ประกาศในลักษณะที่ตัดสินใจโดยไม่มี คีย์เวิร์ด def จะเรียกว่าฟังก์ชันที่ไม่ระบุชื่อ
หากต้องการสร้างฟังก์ชันที่ไม่ระบุตัวตน ให้ใช้คำ สำคัญ Lamba
- ไม่มีการจำกัดจำนวนอาร์กิวเมนต์ที่ แลมบ์ดา รับได้ อย่างไรก็ตาม มันจะคืนค่าหนึ่งค่าเท่านั้น
- ไม่สามารถเรียกฟังก์ชันที่ไม่ระบุชื่อให้พิมพ์ได้โดยตรง
- แลมบ์ดา มีเนมสเปซอื่นและไม่สามารถยอมรับตัวแปรที่ไม่อยู่ในรายการพารามิเตอร์ได้
ไวยากรณ์ของ ฟังก์ชัน แลมบ์ดา
มันเป็นเพียงคำสั่งบรรทัดเดียว:
แลมบ์ดา [arg1 [,arg2,…..argn]]:expression
ตัวอย่าง:
สี่เหลี่ยม = แลมบ์ดา x: x*x
พิมพ์(สี่เหลี่ยม(3))
เอาท์พุท:
9
การเรียกซ้ำใน Python
การเรียกซ้ำเป็นหนึ่งในฟังก์ชันที่สำคัญที่สุดใน Python
การเรียกซ้ำหมายถึงฟังก์ชันที่กำหนดไว้สามารถเรียกตัวเองได้ ช่วยวนซ้ำข้อมูลซ้ำแล้วซ้ำอีกเพื่อให้ได้ผลลัพธ์
ข้อผิดพลาดที่พบบ่อยที่สุดประการหนึ่งในการเรียกซ้ำคือเมื่อคุณเขียนฟังก์ชันที่เรียกตัวเองอย่างต่อเนื่องและไม่ยุติ ซึ่งส่งผลให้มีการใช้พลังงานมากเกินไป
ตรวจสอบโปรแกรมต่อไปนี้
ตัวอย่าง:
def เรียกซ้ำ (k):
ถ้า(k > 0):
ผลลัพธ์ = k + เรียกซ้ำ (k – 1)
พิมพ์(ผล)
อื่น:
ผลลัพธ์ = 0
ส่งคืนผลลัพธ์
พิมพ์(“\n\nผลลัพธ์การเรียกซ้ำ”)
เรียกซ้ำ(3)
เอาท์พุท:
ผลการเรียกซ้ำ
1
3
6
ในสิ่งนี้ recursive(k) คือชื่อของฟังก์ชันที่จะเรียกตัวเอง นั่นคือ recurse
k คือตัวแปร ซึ่งลดลง 1 { (k – 1) } ทุกครั้งที่เรียกกลับ
ช่วงเวลาที่เงื่อนไข k > 0 ไม่เป็นไปตามที่กำหนด การเรียกซ้ำจะหยุดชะงัก
อ่านเพิ่มเติม: Python Recursive Function Concept
ข้อดีของการเรียกซ้ำ
นี่คือข้อดีที่สำคัญที่สุดของการเรียกซ้ำ:
- รหัสหรือโปรแกรมดูสะอาดตาและเข้าใจง่าย
- ด้วยการเรียกซ้ำ ฟังก์ชันที่ซับซ้อนสามารถแบ่งออกเป็นปัญหาที่ง่ายขึ้นได้
- การสร้างซีเควนซ์ทำได้ง่ายกว่าด้วยการเรียกซ้ำที่เป็นการวนซ้ำแบบซ้อน
ข้อจำกัดของการเรียกซ้ำ
นี่คือข้อจำกัดบางประการของการเรียกซ้ำ:
- บางครั้งก็เป็นการยากที่จะเข้าใจตรรกะที่อยู่เบื้องหลังฟังก์ชันแบบเรียกซ้ำ
- เนื่องจากฟังก์ชันเรียกตัวเองหลายครั้ง ฟังก์ชันแบบเรียกซ้ำจึงใช้หน่วยความจำและเวลาเป็นจำนวนมาก จึงไม่มีประสิทธิภาพ
- การดีบักฟังก์ชันแบบเรียกซ้ำค่อนข้างซับซ้อน
อ่าน: แอปพลิเคชั่น Python 12 อันดับแรกที่น่าสนใจในโลกแห่งความจริง
ฟีโบนักชีใน Python
อย่างที่คุณทราบ ดอกทานตะวัน รหัส Da Vinci และเพลง "Lateralus" ของ Tool ล้วนมีพื้นฐานมาจากสิ่งหนึ่ง นั่นคือตัวเลขฟีโบนักชี
ตัวเลขฟีโบนักชีคือตัวเลขที่เรียงตามลำดับของค่าจำนวนเต็มต่อไปนี้:
0,1,1,2,3,5,8,13,21,34,55,89,….
ลำดับนี้ถูกกำหนดโดย:
F n = F n-1 + F n-2
ที่ไหน,
F 0 = 0
และ
F 1 = 1
ใน Python รหัสเพื่อรับหมายเลข n ของ ลำดับ Fibonacci นั้นเขียนโดยใช้การเรียกซ้ำ:
def ฟีโบนักชี(n):
ถ้า n<0:
พิมพ์("ป้อนข้อมูลไม่ถูกต้อง")
เอลฟ์ n==1:
ส่งคืน 0
เอลฟ์ n==2:
กลับ 1
อื่น:
ส่งกลับ ฟีโบนักชี(n-1)+ฟีโบนักชี(n-2)
พิมพ์(ฟีโบนักชี(13))
เอาท์พุท:
144
ซึ่งหมายความว่าตัวเลขที่ 13 ใน อนุกรม ฟีโบนักชีคือ 144
บทสรุป
ในโพสต์นี้ คุณได้เรียนรู้เกี่ยวกับฟังก์ชัน Python ประเภทต่างๆ และวิธีใช้งานเพื่อให้ได้ผลลัพธ์ที่ต้องการ
อย่างไรก็ตาม สิ่งสำคัญคือต้องระวังให้มากในขณะที่ใช้แต่ละฟังก์ชัน เนื่องจากไวยากรณ์จะแตกต่างกันไป
แม้แต่โคลอนเดียวก็สร้างความแตกต่างได้!
ในทำนองเดียวกัน การใช้การเรียกซ้ำสามารถช่วยแก้ปัญหาทางคณิตศาสตร์ที่ซับซ้อนต่างๆ ได้ แต่ในขณะเดียวกันก็ต้องใช้อย่างระมัดระวัง มิฉะนั้น อาจเป็นเรื่องยากที่จะดีบักฟังก์ชันแบบเรียกซ้ำของคุณ
บทช่วยสอนนี้จะช่วยให้คุณเขียนโค้ดใน Python ได้ดีขึ้นอย่างแน่นอน
หากคุณอยากรู้ที่จะเรียนรู้เกี่ยวกับวิทยาศาสตร์ข้อมูล ลองดูโปรแกรม Data Science ของ upGrad ซึ่งสร้างขึ้นสำหรับมืออาชีพที่ทำงานและมีกรณีศึกษาและโครงการมากกว่า 10 รายการ เวิร์กช็อปภาคปฏิบัติจริง การให้คำปรึกษากับผู้เชี่ยวชาญในอุตสาหกรรม ตัวต่อตัวกับที่ปรึกษาในอุตสาหกรรม , การเรียนรู้มากกว่า 400 ชั่วโมง และการช่วยเหลืองานกับบริษัทชั้นนำ
ประเภทของฟังก์ชันหลักใน Python มีอะไรบ้าง
ฟังก์ชันเป็นส่วนที่สำคัญที่สุดของภาษาการเขียนโปรแกรมใดๆ เนื่องจากช่วยลดความซับซ้อนของการดำเนินการทั่วไปที่มักจะทำซ้ำ ฟังก์ชันคือชุดคำสั่งสำหรับการทำงานเฉพาะ ทำให้ง่ายต่อการทำสิ่งเดิมซ้ำๆ โดยไม่จำเป็นต้องเขียนโค้ดเดิมซ้ำอีก มีฟังก์ชันมากมายที่ใช้ใน Python สำหรับการทำงานเฉพาะตามความต้องการของผู้ใช้ มีฟังก์ชันในตัวบางอย่างใน Python เพื่อทำให้งานของคุณง่ายขึ้น ตัวอย่างเช่น คุณสามารถรับค่าต่ำสุดจากชุดตัวเลขได้โดยตรงโดยใช้ฟังก์ชัน min() สำหรับการดำเนินการที่กำหนดเอง ผู้ใช้จำเป็นต้องสร้างฟังก์ชันที่ผู้ใช้กำหนดเองเพื่อทำงานนั้น นอกจากนี้ยังมีไม่ระบุชื่อซึ่งไม่ได้ประกาศด้วยคำหลัก 'def' มาตรฐาน
Python มีฟังก์ชันในตัวกี่ฟังก์ชัน
หากคุณกำลังใช้หรือเรียนภาษา Python คุณจะทราบดีถึงความจำเป็นในการใช้งานฟังก์ชันของมัน Python เป็นเหมือนภาษาที่ไม่สมบูรณ์โดยไม่มีไลบรารีของฟังก์ชันในตัวที่ทำให้ง่ายต่อการทำงานใดๆ โดยไม่ต้องให้คำสั่งจำนวนมาก มี 68 ฟังก์ชันในตัวที่มีอยู่ใน Python เพื่อทำให้งานของนักพัฒนาทุกคนง่ายขึ้น นักพัฒนาไม่จำเป็นต้องสร้างฟังก์ชันของตนเองสำหรับงานทุกๆ งาน เช่น การสรุปค่าของจำนวนเต็มสองตัว เพราะมีฟังก์ชัน 'sum()' ในตัวที่จะทำเพื่อพวกเขา
ฟังก์ชั่นเวทย์มนตร์ใน Python คืออะไร?
เมธอดเวทย์มนตร์ยังมีชื่อเสียงในฐานะเมธอด Dunder ใน Python เหล่านี้เป็นวิธีการที่ประกอบด้วยคำนำหน้าสองคำ เช่นเดียวกับคำต่อท้ายสองคำ ขีดเส้นใต้ในชื่อวิธีการ ชื่อที่นี่คือ Dunder เนื่องจาก 'Double Underscores' ฟังก์ชันมายากลเหล่านี้มักใช้สำหรับการโอเวอร์โหลดของผู้ปฏิบัติงาน ตัวอย่างของฟังก์ชันเวทย์มนตร์ใน Python ได้แก่ __len__, __add__ เป็นต้น