Python ฟังก์ชันแลมบ์ดาพร้อมตัวอย่าง

ฟังก์ชั่นแลมบ์ดาคืออะไร Python?

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

In Pythonนิพจน์แลมบ์ดา (หรือรูปแบบแลมบ์ดา) ถูกนำมาใช้เพื่อสร้างฟังก์ชันที่ไม่ระบุชื่อ โดยคุณจะใช้ไฟล์ แลมบ์ดา คำหลัก (เช่นเดียวกับที่คุณใช้ def เพื่อกำหนดฟังก์ชันปกติ) ทุกฟังก์ชันที่ไม่ระบุตัวตนที่คุณกำหนด Python จะมีส่วนสำคัญ 3 ส่วน คือ

• คำหลักแลมบ์ดา
• พารามิเตอร์ (หรือตัวแปรที่ถูกผูกไว้) และ
• ฟังก์ชั่นร่างกาย

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

ไวยากรณ์และตัวอย่าง

ไวยากรณ์อย่างเป็นทางการในการเขียนฟังก์ชันแลมบ์ดามีดังต่อไปนี้:

lambda p1, p2: expression

ในที่นี้ p1 และ p2 คือพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชันแลมบ์ดา คุณสามารถเพิ่มพารามิเตอร์ได้มากหรือน้อยตามที่คุณต้องการ

อย่างไรก็ตาม โปรดสังเกตว่าเราไม่ได้ใช้วงเล็บเหลี่ยมล้อมรอบพารามิเตอร์เหมือนกับฟังก์ชันทั่วไป ส่วนสุดท้าย (นิพจน์) คือนิพจน์ใดๆ ที่ถูกต้อง Python นิพจน์ที่ทำงานกับพารามิเตอร์ที่คุณระบุให้กับฟังก์ชัน

1 ตัวอย่าง

ตอนนี้คุณรู้เกี่ยวกับแลมบ์ดาแล้ว เรามาลองดูตัวอย่างกัน ดังนั้นเปิดของคุณ IDLE และพิมพ์ตามนี้:

adder = lambda x, y: x + y
print (adder (1, 2))

Code คำอธิบาย

ที่นี่ เรากำหนดตัวแปรที่จะเก็บผลลัพธ์ที่ส่งคืนโดยฟังก์ชันแลมบ์ดา

1. คีย์เวิร์ด lambda ที่ใช้กำหนดฟังก์ชันที่ไม่ระบุชื่อ

2. x และ y คือพารามิเตอร์ที่เราส่งผ่านไปยังฟังก์ชันแลมบ์ดา

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

4. เราเรียกใช้ฟังก์ชันและพิมพ์ค่าที่ส่งคืน

2 ตัวอย่าง

นั่นเป็นตัวอย่างพื้นฐานเพื่อทำความเข้าใจหลักการและไวยากรณ์ของแลมบ์ดา ตอนนี้เรามาลองพิมพ์แลมบ์ดาออกมาและดูผลลัพธ์กันอีกครั้ง เปิดไฟล์ของคุณ IDLE และพิมพ์ตามนี้:

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

ตอนนี้บันทึกไฟล์ของคุณแล้วกด F5 เพื่อเรียกใช้โปรแกรม นี่คือผลลัพธ์ที่คุณควรได้รับ

Output:

<function <lambda> at 0x00000185C3BF81E0>

เกิดอะไรขึ้นที่นี่? มาดูโค้ดกันเพื่อทำความเข้าใจเพิ่มเติม

Code คำอธิบาย:

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

2. เราประกาศฟังก์ชันแลมบ์ดาที่เรียกใช้คำสั่ง print และพิมพ์ผลลัพธ์ออกมา

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

3 ตัวอย่าง

อย่างไรก็ตาม หากคุณเขียนโปรแกรมในลักษณะนี้:

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

จากนั้นเรียกใช้งานโดยกดปุ่ม F5 คุณจะเห็นผลลัพธ์แบบนี้

Output:

some kind of a useless lambda

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

Code คำอธิบาย:

1. นี่คือสตริงเดียวกันกับที่เรากำหนดไว้ในตัวอย่างก่อนหน้านี้

2. ในส่วนนี้ เราจะกำหนดฟังก์ชันแลมบ์ดาและเรียกใช้งานทันทีโดยส่งสตริงเป็นอาร์กิวเมนต์ นี่คือสิ่งที่เรียกว่า IIFE (Intelligent Interpreter Function) และคุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับเรื่องนี้ในส่วนถัดไปของบทเรียนนี้

4 ตัวอย่าง

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

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

ตอนนี้ บันทึกไฟล์แล้วกด F5 เพื่อเรียกใช้โปรแกรม ถ้าคุณไม่ได้ทำผิดพลาดอะไร ผลลัพธ์ควรจะเป็นประมาณนี้

Output:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code คำอธิบาย:

1. ฟังก์ชันชื่อ guru ซึ่งรับฟังก์ชันอื่นเป็นพารามิเตอร์ตัวแรก และตามด้วยอาร์กิวเมนต์อื่นๆ

2. printer_one เป็นฟังก์ชันง่ายๆ ที่พิมพ์ค่าพารามิเตอร์ที่ส่งเข้ามาและส่งคืนค่านั้น

3. printer_two คล้ายกับ printer_one แต่ไม่มีคำสั่ง return

4. ในส่วนนี้ เราจะเรียกใช้ฟังก์ชัน guru และส่งฟังก์ชันของเครื่องพิมพ์และสตริงเป็นพารามิเตอร์

5. นี่คือไวยากรณ์ที่จะใช้ในการดำเนินการขั้นตอนที่สี่ (เช่น การเรียกใช้ฟังก์ชันผู้เชี่ยวชาญ) โดยใช้แลมบ์ดา

ในส่วนถัดไป คุณจะได้เรียนรู้วิธีใช้ฟังก์ชัน lambda ด้วย แผนที่(), ลด()และ กรอง() in Python.

การใช้แลมบ์ดาด้วย Python ในตัว

ฟังก์ชัน Lambda มอบวิธีการอันสง่างามและทรงพลังในการดำเนินการโดยใช้วิธีการในตัว Python- เป็นไปได้เนื่องจาก lambdas สามารถเรียกใช้ได้ทันทีและส่งผ่านเป็นอาร์กิวเมนต์ของฟังก์ชันเหล่านี้

IIFE เข้า Python แลมบ์ดา

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

 (lambda x: x + x)(2)

นี่คือคำอธิบายผลลัพธ์และโค้ด:

ความสามารถของแลมบ์ดาที่จะเรียกใช้ได้ทันทีทำให้คุณสามารถใช้มันภายในฟังก์ชันเช่น map() และ ลด () มันมีประโยชน์เพราะคุณอาจไม่ต้องการใช้ฟังก์ชันเหล่านี้อีก

แลมบ์ดาในตัวกรอง ()

ฟังก์ชั่นตัวกรองใช้เพื่อเลือกองค์ประกอบเฉพาะจากลำดับขององค์ประกอบ ลำดับสามารถเป็นตัววนซ้ำใดๆ เช่น รายการ เซต สิ่งอันดับ ฯลฯ

องค์ประกอบที่จะถูกเลือกนั้นขึ้นอยู่กับข้อจำกัดที่กำหนดไว้ล่วงหน้า โดยรับพารามิเตอร์ 2 ตัว:

• ฟังก์ชันที่กำหนดข้อจำกัดในการกรอง
• ลำดับ (ตัววนซ้ำใดๆ เช่น รายการ สิ่งอันดับ ฯลฯ)

ตัวอย่างเช่น

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

นี่คือผลลัพธ์:

[10, 8, 7, 5, 11]

Code คำอธิบาย:

1. ในคำสั่งแรก เราจะกำหนดรายการที่เรียกว่าลำดับซึ่งประกอบด้วยตัวเลขบางตัว

2. ที่นี่ เราประกาศตัวแปรชื่อ filtered_result ซึ่งจะเก็บค่าที่กรองแล้วที่ส่งคืนโดยฟังก์ชัน filter()

3. ฟังก์ชันแลมบ์ดาที่ทำงานบนแต่ละองค์ประกอบของรายการและส่งกลับค่าจริงหากค่านั้นมากกว่า 4

4. พิมพ์ผลลัพธ์ที่ส่งคืนโดยฟังก์ชันตัวกรอง

แลมบ์ดาในแผนที่ ()

ฟังก์ชัน `map` ใช้สำหรับดำเนินการเฉพาะอย่างกับทุกองค์ประกอบในลำดับ เช่นเดียวกับฟังก์ชัน `filter()` ฟังก์ชันนี้ก็รับพารามิเตอร์ 2 ตัวเช่นกัน:

1. ฟังก์ชันที่กำหนดการดำเนินการที่จะทำกับองค์ประกอบต่างๆ
2. ลำดับหนึ่งหรือหลายลำดับ

ตัวอย่างเช่น นี่คือโปรแกรมที่พิมพ์ตัวเลขกำลังสองในรายการที่กำหนด:

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

Output:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

Code คำอธิบาย:

1. ในที่นี้ เรากำหนดรายการที่เรียกว่าลำดับ ซึ่งประกอบด้วยตัวเลขบางส่วน

2. เราประกาศตัวแปรชื่อ filtered_result ซึ่งจะใช้เก็บค่าที่แมปไว้

3. ฟังก์ชันแลมบ์ดาที่ทำงานกับแต่ละองค์ประกอบในรายการและส่งคืนค่ากำลังสองของตัวเลขนั้น

4. พิมพ์ผลลัพธ์ที่ได้จากฟังก์ชัน map

แลมบ์ดาลด ()

ฟังก์ชัน reduce เช่น map() ใช้ในการดำเนินการกับทุกองค์ประกอบในลำดับ อย่างไรก็ตาม ฟังก์ชันนี้แตกต่างจาก map ตรงที่การทำงาน ต่อไปนี้คือขั้นตอนที่ฟังก์ชัน reduce() ปฏิบัติตามเพื่อคำนวณเอาต์พุต:

ขั้นตอน 1) ดำเนินการตามการดำเนินการที่กำหนดไว้กับ 2 องค์ประกอบแรกของลำดับ

ขั้นตอน 2) บันทึกผลลัพธ์นี้

ขั้นตอน 3) ดำเนินการด้วยผลลัพธ์ที่บันทึกและองค์ประกอบถัดไปในลำดับ

ขั้นตอน 4) ทำซ้ำจนกว่าจะไม่มีองค์ประกอบเหลืออยู่

นอกจากนี้ยังใช้พารามิเตอร์สองตัวด้วย:

1. ฟังก์ชั่นที่กำหนดการดำเนินการที่จะดำเนินการ
2. ลำดับ (ตัววนซ้ำใดๆ เช่น รายการ สิ่งอันดับ ฯลฯ)

ตัวอย่างเช่น นี่คือโปรแกรมที่ส่งคืนผลคูณขององค์ประกอบทั้งหมดในรายการ:

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

นี่คือผลลัพธ์:

120

Code คำอธิบาย:

1. นำเข้าฟังก์ชัน reduce จากโมดูล functools

2. ในที่นี้ เรากำหนดรายการที่เรียกว่าลำดับ ซึ่งประกอบด้วยตัวเลขบางส่วน

3. เราประกาศตัวแปรชื่อ product ซึ่งจะเก็บค่าที่ลดลงแล้ว

4. ฟังก์ชันแลมบ์ดาที่ทำงานกับแต่ละองค์ประกอบในรายการ โดยจะส่งคืนผลคูณของตัวเลขนั้นตามผลลัพธ์ก่อนหน้า

5. พิมพ์ผลลัพธ์ที่ได้จากฟังก์ชัน reduce

ทำไม (และทำไมไม่) ใช้ฟังก์ชันแลมบ์ดา?

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

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

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

มันช่วยให้คุณสามารถส่งฟังก์ชันเป็นพารามิเตอร์ให้กับฟังก์ชันอื่นได้ (ตัวอย่างเช่น ในฟังก์ชัน map, filter เป็นต้น) ในกรณีเช่นนี้ การใช้แลมบ์ดาเป็นวิธีที่สง่างามในการสร้างฟังก์ชันที่ใช้เพียงครั้งเดียวและส่งเป็นพารามิเตอร์

เมื่อใดที่คุณไม่ควรใช้ Lambda

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

Lambdas กับฟังก์ชันปกติ

ดังที่กล่าวไว้ก่อนหน้านี้ แลมบ์ดาเป็นเพียงฟังก์ชันที่ไม่มีตัวระบุผูกติดอยู่กับมัน กล่าวอย่างง่ายๆ ก็คือ ฟังก์ชันที่ไม่มีชื่อ (ดังนั้นจึงเรียกว่า ฟังก์ชันนิรนาม) ต่อไปนี้เป็นตารางเพื่อแสดงความแตกต่างระหว่างแลมบ์ดาและฟังก์ชันทั่วไป Python.

lambda x : x + x

def (x) :
return x + x 

อธิบายความแตกต่าง

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

ฟังก์ชันปกติสำหรับตัวอย่างข้างต้นจะมีลักษณะดังนี้:

def adder (x, y):
return x + y 
print (adder (1, 2))

ในที่นี้ เราต้องนิยาม a พร้อมชื่อ สำหรับฟังก์ชันซึ่ง รับคืน ผลลัพธ์เมื่อเรา โทรศัพท์ ฟังก์ชันแลมบ์ดาไม่มีคำสั่ง return เพราะจะมีเพียงนิพจน์เดียวซึ่งจะถูกส่งกลับโดยค่าเริ่มต้นเสมอ คุณไม่จำเป็นต้องกำหนดค่าให้กับแลมบ์ดาด้วยซ้ำ เพราะสามารถเรียกใช้งานได้ทันที (ดูในส่วนก่อนหน้า) ดังที่คุณจะเห็น แลมบ์ดาจะมีประสิทธิภาพเป็นพิเศษเมื่อเราใช้มันร่วมกับ... Pythonฟังก์ชันในตัวของ

อย่างไรก็ตาม คุณอาจยังคงสงสัยว่า lambdas แตกต่างจากฟังก์ชันที่ส่งคืนนิพจน์เดียวอย่างไร (เหมือนกับตัวอย่างข้างต้น) ในระดับล่ามไม่มีความแตกต่างกันมากนัก อาจฟังดูน่าประหลาดใจ แต่ฟังก์ชัน lambda ใดๆ ที่คุณกำหนดไว้ Python ล่ามจะถือเป็นฟังก์ชันปกติ

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

คำถามที่พบบ่อย