คำแนะนำขั้นสูงสำหรับฟังก์ชันแผนที่ Python สำหรับการประมวลผลข้อมูล

การแนะนำ

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

ไวยากรณ์สำหรับฟังก์ชัน map() เป็นดังนี้:

map(function, iterable, [iterable 2, iterable 3, ...])

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

ในบทช่วยสอนนี้ เราจะพูดถึงสามวิธีในการทำงานกับ map(): ด้วยฟังก์ชัน lambda ด้วยฟังก์ชันที่ผู้ใช้กำหนด และสุดท้ายด้วยฟังก์ชันบิวด์ ในฟังก์ชันโดยใช้อาร์กิวเมนต์ที่ทำซ้ำได้หลายรายการ

การใช้ฟังก์ชันแลมบ์ดา

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

ไวยากรณ์ของ map() พร้อมด้วยฟังก์ชัน lambda เป็นดังนี้:

map(lambda item: item[] expression, iterable)

ด้วยรายการดังต่อไปนี้ เราสามารถใช้ฟังก์ชัน lambda พร้อมด้วยนิพจน์ที่เราต้องการใช้กับแต่ละรายการในรายการของเรา:

numbers = [10, 15, 21, 33, 42, 55]

หากต้องการใช้นิพจน์กับตัวเลขแต่ละตัว เราสามารถใช้ map() และ lambda:

mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))

ที่นี่เราประกาศรายการในรายการของเราเป็น x จากนั้นเราก็เพิ่มการแสดงออกของเรา เราส่งผ่านรายการตัวเลขของเราเป็นค่าที่สามารถทำซ้ำได้สำหรับ map()

เพื่อที่จะรับผลลัพธ์ทันที เราจะพิมพ์รายการวัตถุ map:

print(mapped_numbers)

[23, 33, 45, 69, 87, 113]

เราได้ใช้ list() เพื่อให้วัตถุแผนที่ถูกส่งกลับมาให้เราเป็นรายการ แทนที่จะเป็นวัตถุที่มนุษย์อ่านได้น้อย เช่น: วัตถุแผนที่เป็นตัววนซ้ำเหนือผลลัพธ์ของเรา ดังนั้นเราจึงสามารถวนซ้ำด้วย for หรือเราสามารถใช้ list() เพื่อเปลี่ยนให้เป็นรายการ เรากำลังทำเช่นนี้เนื่องจากเป็นวิธีที่ดีในการตรวจสอบผลลัพธ์

ท้ายที่สุดแล้ว map() จะมีประโยชน์มากที่สุดเมื่อทำงานกับชุดข้อมูลขนาดใหญ่ ดังนั้นเราน่าจะทำงานกับออบเจ็กต์แผนที่เพิ่มเติมได้ และโดยทั่วไปจะไม่ใช้ Constructor เช่น list() กับพวกเขา

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

การใช้ฟังก์ชันที่ผู้ใช้กำหนด

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

ตัวอย่างเช่น ในการทำซ้ำต่อไปนี้ แต่ละรายการจะเป็นพจนานุกรมที่มีรายละเอียดที่แตกต่างกันเกี่ยวกับสัตว์ในพิพิธภัณฑ์สัตว์น้ำแต่ละชนิดของเรา:

aquarium_creatures = [
 {"name": "sammy", "species": "shark", "tank number": 11, "type": "fish"},
 {"name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish"},
 {"name": "jo", "species": "guppy", "tank number": 18, "type": "fish"},
 {"name": "jackie", "species": "lobster", "tank number": 21, "type": "shellfish"},
 {"name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish"},
 {"name": "olly", "species": "green turtle", "tank number": 34, "type": "turtle"}
]

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

def assign_to_tank(aquarium_creatures, new_tank_number):
 def apply(x):
  x["tank number"] = new_tank_number
  return x
 return map(apply, aquarium_creatures)

เรากำหนดฟังก์ชัน assign_to_tank() ที่จะรับ aquarium_creatures และ new_tank_number เป็นพารามิเตอร์ ใน assign_to_tank() เราจะส่ง apply() เป็นฟังก์ชันให้กับ map() ในบรรทัดสุดท้าย ฟังก์ชัน assign_to_tank จะส่งคืนตัววนซ้ำที่เกิดจาก map()

apply() รับ x เป็นอาร์กิวเมนต์ ซึ่งแสดงถึงรายการในรายการของเรา — พจนานุกรมเดียว

ต่อไปเราจะกำหนดว่า x คือคีย์ "tank number" จาก aquarium_creatures และควรเก็บค่าที่ส่งผ่านไว้ใน new_tank_number. เราคืนสินค้าแต่ละรายการหลังจากใช้หมายเลขถังใหม่

เราเรียก assign_to_tank() พร้อมรายการพจนานุกรมและหมายเลขแทงค์ใหม่ที่เราต้องการแทนที่สำหรับสิ่งมีชีวิตแต่ละตัว:

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

เมื่อฟังก์ชันเสร็จสมบูรณ์ เราจะเก็บวัตถุแผนที่ของเราไว้ในตัวแปร assigned_tanks ซึ่งเราจะเปลี่ยนเป็นรายการและพิมพ์:

print(list(assigned_tanks))

เราจะได้ผลลัพธ์ต่อไปนี้จากโปรแกรมนี้:

[{'name': 'sammy', 'species': 'shark', 'tank number': 42, 'type': 'fish'}, {'name': 'ashley', 'species': 'crab', 'tank number': 42, 'type': 'shellfish'}, {'name': 'jo', 'species': 'guppy', 'tank number': 42, 'type': 'fish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': 42, 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': 42, 'type': 'fish'}, {'name': 'olly', 'species': 'green turtle', 'tank number': 42, 'type': 'turtle'}]

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

การใช้ฟังก์ชันในตัวที่มีการทำซ้ำได้หลายรายการ

เช่นเดียวกับฟังก์ชัน lambda หรือฟังก์ชันที่เรากำหนดไว้ เราสามารถใช้ฟังก์ชันในตัวของ Python กับ map() ได้ หากต้องการใช้ฟังก์ชันที่มีหลายตัวที่ทำซ้ำได้ เราจะส่งชื่อที่สามารถทำซ้ำได้อีกชื่อหนึ่งตามหลังชื่อแรก ตัวอย่างเช่น การใช้ฟังก์ชัน pow() ที่จะรับตัวเลขสองตัวเพื่อค้นหากำลังของเลขฐานกับเลขชี้กำลังที่ระบุ

ที่นี่เรามีรายการจำนวนเต็มที่เราอยากจะใช้กับ pow():

base_numbers = [2, 4, 6, 8, 10]
powers = [1, 2, 3, 4, 5]

ต่อไปเราจะส่ง pow() เป็นฟังก์ชันของเราไปที่ map() และระบุสองรายการเป็นรายการที่สามารถทำซ้ำได้:

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

map() จะใช้ฟังก์ชัน pow() กับรายการเดียวกันในแต่ละรายการเพื่อให้พลังงาน ดังนั้นผลลัพธ์ของเราจะแสดง 2**1, 4**2, 6**3 และอื่นๆ:

[2, 16, 216, 4096, 100000]

หากเราต้องระบุ map() ด้วยตัววนซ้ำที่ยาวกว่าตัวอื่น map() จะหยุดการคำนวณเมื่อถึงจุดสิ้นสุดของตัววนซ้ำที่สั้นที่สุด ในโปรแกรมต่อไปนี้ เรากำลังขยาย base_numbers ด้วยตัวเลขเพิ่มเติมสามตัว:

base_numbers = [2, 4, 6, 8, 10, 12, 14, 16]
powers = [1, 2, 3, 4, 5]

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

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

[2, 16, 216, 4096, 100000]

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

บทสรุป

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

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

เพื่อทำความเข้าใจ Python ให้ลึกซึ้งยิ่งขึ้น โปรดใช้แหล่งข้อมูลต่อไปนี้:

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

แหล่งข้อมูลเหล่านี้จะช่วยให้คุณมีความเข้าใจอย่างครอบคลุมเกี่ยวกับความสามารถของ Python และวิธีการใช้งานอย่างมีประสิทธิภาพในโครงการของคุณ

หากคุณต้องการเรียนรู้ Python เพิ่มเติม โปรดดูชุดวิธีเขียนโค้ดใน Python และหน้าหัวข้อ Python ของเรา หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการทำงานกับชุดข้อมูลในการเขียนโปรแกรมเชิงฟังก์ชัน โปรดดูบทความของเราเกี่ยวกับฟังก์ชัน filter()

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

map() ใน Python ทำหน้าที่อะไร

ฟังก์ชัน map() ใน Python รับฟังก์ชันและการวนซ้ำอย่างน้อยหนึ่งรายการ และส่งคืนตัววนซ้ำที่ใช้ฟังก์ชันที่กำหนดกับแต่ละองค์ประกอบของการวนซ้ำที่ให้มา กล่าวอีกนัยหนึ่ง มันจะ "แมปฟังก์ชัน" กับแต่ละรายการในการทำซ้ำได้ ตัวอย่างเช่น:

numbers = [1, 2, 3, 4]
squares = map(lambda x: x**2, numbers)

ในที่นี้ squares จะเป็นตัววนซ้ำของ 1, 4, 9, 16

คุณจะสร้างแผนที่ใน Python ได้อย่างไร?

คุณสร้างวัตถุแผนที่โดยการเรียกใช้ฟังก์ชัน map() ในตัวพร้อมฟังก์ชันและอย่างน้อยหนึ่งรายการที่สามารถทำซ้ำได้เป็นอาร์กิวเมนต์ ตัวอย่างเช่น:

def add_one(x):
    return x + 1

my_list = [1, 2, 3]
mapped = map(add_one, my_list)  # Creates a map object

จากนั้นคุณสามารถวนซ้ำผ่านการแมปหรือแปลงเป็นรายการเพื่อดูผลลัพธ์:

print(list(mapped))  # [2, 3, 4]

แผนที่ขี้เกียจใน Python หรือไม่?

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

ฟังก์ชัน `map()` ทำงานอย่างไร

ฟังก์ชัน map() ทำงานดังนี้:

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

หากมีการระบุการทำซ้ำได้หลายรายการ map() จะหยุดลงเมื่อการทำซ้ำที่สั้นที่สุดหมดลง ตัวอย่างเช่น:

numbers = [1, 2, 3]
others = [10, 20, 30]
result = map(lambda x, y: x + y, numbers, others)
print(list(result))  # [11, 22, 33]

ฉันควรใช้ `map` ใน Python หรือไม่

คุณควรใช้ map() หรือไม่นั้นขึ้นอยู่กับความชอบส่วนตัวและความสามารถในการอ่าน:

ข้อดี:

อาจกระชับกว่านี้ในบางกรณี
อาจเร็วกว่ารายการความเข้าใจเล็กน้อยในบางสถานการณ์ (แต่มักจะไม่มากนัก)

ข้อเสีย:

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

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

วิธีแปลง `map` เป็น string ใน Python

อ็อบเจ็กต์ map เป็นตัววนซ้ำ ไม่ใช่สตริง หากคุณต้องการแปลงผลลัพธ์ของการเรียก map() ไปเป็นสตริง คุณต้องวนซ้ำก่อน แนวทางทั่วไป ได้แก่:

การแปลงเป็นรายการและจากนั้นเป็นการแทนค่าสตริง:

mapped = map(str, [1, 2, 3])
string_representation = str(list(mapped))  # "[‘1’, ‘2’, ‘3’]"

เข้าร่วมผลลัพธ์หากเป็นองค์ประกอบสตริง:

mapped = map(str, [1, 2, 3])
joined_string = ''.join(mapped)  # "123"

วิธีที่ดีที่สุดขึ้นอยู่กับว่าคุณต้องการการแสดงรายการที่มนุษย์สามารถอ่านได้ (str(list(...))) หรือการต่อผลลัพธ์ (''.join(... ))

`จำนวนแผนที่()` ทำหน้าที่อะไร

วัตถุ map ใน Python ไม่มีเมธอด count() ในตัว วิธีการ count() มีอยู่ในรายการ สตริง และคอลเลกชันอื่นๆ บางรายการ หากคุณต้องการนับการเกิดขึ้นของค่าที่สร้างโดยวัตถุแผนที่ คุณต้องแปลงเป็นรายการก่อน (ซึ่งใช้ตัววนซ้ำ):

mapped = map(lambda x: x*2, [1, 2, 3, 2])
mapped_list = list(mapped)
count_of_4 = mapped_list.count(4)  # 2, because 2*2=4 appears twice

หากคุณต้องการนับโดยไม่ต้องแปลงเป็นรายการ คุณสามารถวนซ้ำด้วยตนเอง:

count_of_value = sum(1 for x in map(lambda x: x*2, [1, 2, 3, 2]) if x == 4)

`map` และ `filter` ทำหน้าที่อะไรใน Python

map(function, iterable): ใช้ฟังก์ชันกับแต่ละองค์ประกอบของ iterable และส่งคืนตัววนซ้ำของผลลัพธ์
filter(function, iterable): ส่งคืนตัววนซ้ำขององค์ประกอบจากการวนซ้ำซึ่งฟังก์ชัน (องค์ประกอบ) เป็น True ถ้าฟังก์ชันเป็นไม่มี ก็จะส่งกลับองค์ประกอบที่เป็นความจริงด้วยตัวเอง

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

nums = [1, 2, 3, 4, 5]
mapped_nums = map(lambda x: x*2, nums)        # [2, 4, 6, 8, 10]
filtered_nums = filter(lambda x: x > 2, nums) # [3, 4, 5]

map แปลงแต่ละองค์ประกอบ ในขณะที่ filter เลือกองค์ประกอบบางอย่างตามเงื่อนไข