ฟังก์ชัน 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__ เป็นต้น