บทช่วยสอนความเข้าใจพจนานุกรม Python

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

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

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

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

สารบัญ

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

ความเข้าใจในพจนานุกรม Python คืออะไร?

Python Dictionary Comprehension เป็นวิธีที่กระชับในการสร้างพจนานุกรมโดยใช้นิพจน์ง่ายๆ ช่วยให้คุณสร้างพจนานุกรมใหม่โดยไม่จำเป็นต้องใช้ for-loops.e

ลองมาดูตัวอย่างความเข้าใจกัน สมมติว่าคุณมีสองรายการ รายการหนึ่งมีคีย์และอีกรายการหนึ่งมีค่า:

keys = ['a', 'b', 'c']
values = [1, 2, 3]

การใช้ความเข้าใจในพจนานุกรม คุณสามารถสร้างพจนานุกรมใหม่ได้โดยการวนซ้ำสองรายการและรวมคู่คีย์-ค่าที่สอดคล้องกัน:

my_dict = {k: v for k, v in zip(keys, values)}
print(my_dict)

ผลลัพธ์จะเป็น:

{'a': 1, 'b': 2, 'c': 3}

ตัวอย่างข้างต้นควรให้แนวคิดเกี่ยวกับความเข้าใจในPython เพื่อช่วยให้คุณเข้าใจแนวคิดมากขึ้น เรามาทำความเข้าใจไวยากรณ์ของความเข้าใจในพจนานุกรมใน Python กันดีกว่า

การทำความเข้าใจไวยากรณ์ของความเข้าใจในพจนานุกรม

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

โครงสร้างพื้นฐานมีดังนี้:

{key: value for (key, value) in iterable}

ในไวยากรณ์นี้ คีย์และค่าแสดงถึงนิพจน์ที่ใช้สร้างคีย์และค่าของพจนานุกรมที่เป็นผลลัพธ์ iterable ให้แหล่งข้อมูลที่ใช้สร้างคู่คีย์-ค่า

ไวยากรณ์นี้ถูกนำมาใช้ใน Python 3 และ backport ไปจนถึง Python 2.7 เพื่อให้มั่นใจว่าสามารถทำงานร่วมกันได้หลากหลายในเวอร์ชัน Python

ตัวอย่างเช่น ในการสร้างพจนานุกรมที่จับคู่ตัวเลขตั้งแต่ 0 ถึง 4 กับกำลังสองโดยใช้ความเข้าใจในพจนานุกรม คุณสามารถใช้รหัส Python ต่อไปนี้:

square_dict = {x: x**2 for x in range(5)}

สิ่งนี้จะส่งผลให้พจนานุกรมต่อไปนี้:

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

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

keys = ['a', 'b', 'c', 'd', 'e']
values = [1, 2, 3, 4, 5]
my_dict = {k: v for k, v in zip(keys, values)}

พจนานุกรมผลลัพธ์จะเป็น:

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

ความเข้าใจในพจนานุกรมยังช่วยให้คุณเพิ่มคำสั่ง if ที่เป็นทางเลือกที่ส่วนท้ายของความเข้าใจเพื่อใช้ตัวกรองเงื่อนไขกับรายการที่รวมอยู่

ตัวอย่างเช่น คุณสามารถสร้างพจนานุกรมที่มีเฉพาะเลขคู่และกำลังสองโดยใช้ความเข้าใจในพจนานุกรม:

even_square_dict = {x: x**2 for x in range(10) if x % 2 == 0}

ส่งผลให้:

{0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

ตอนนี้คุณคุ้นเคยกับไวยากรณ์ของความเข้าใจแล้ว ลองมาดูตัวอย่างของความเข้าใจกัน

ตัวอย่างของความเข้าใจในพจนานุกรม

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

การแมปตัวเลขกับช่องสี่เหลี่ยม

พิจารณาตัวอย่างง่ายๆ ที่คุณต้องการสร้างพจนานุกรมที่แมปตัวเลขกับกำลังสองโดยใช้ Python dictionary comprehensions:

squares = {x: x**2 for x in range(1, 6)}
print(squares)

สิ่งนี้จะแสดงผล:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

โค้ดด้านบนทำงานเหมือนกับการรันลูป 6 ครั้งและยกกำลังสองให้กับแต่ละตัวเลข รหัสด้านล่างแสดงการวนซ้ำเพื่อรับกำลังสองของตัวเลข:

squares = {}
for x in range(1, 6):
    squares[x] = x ** 2

print(squares)

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

คุณยังสามารถใช้เงื่อนไขกับความเข้าใจของคุณ ตัวอย่างเช่น คุณอาจต้องการสร้างพจนานุกรมที่มีเฉพาะเลขคู่และกำลังสอง:

even_squares = {x: x**2 for x in range(1, 6) if x % 2 == 0}
print(even_squares)

การเรียกใช้รหัสนี้จะสร้างพจนานุกรมใหม่ดังต่อไปนี้:

{2: 4, 4: 16}

คีย์ย้อนกลับและค่า

คุณยังสามารถย้อนกลับองค์ประกอบพจนานุกรมได้อย่างง่ายดายด้วยความเข้าใจในพจนานุกรมใน Python

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

original_dict = {"one": 1, "two": 2, "three": 3, "four": 4}
reversed_dict = {v: k for k, v in original_dict.items()}
print(reversed_dict)

ความเข้าใจในพจนานุกรมข้างต้น (หรือความเข้าใจในพจนานุกรม) จะพิมพ์สิ่งต่อไปนี้:

{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

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

ตัวอย่างที่ให้มาทำหน้าที่เป็นรากฐานที่มั่นคงสำหรับการใช้ความเข้าใจในพจนานุกรมในโครงการ Python ของคุณ

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

ข้อดีหลัก 3 ประการของความเข้าใจในพจนานุกรม

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

1. การสร้างรหัสที่ชัดเจนและเรียบง่าย

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

2. ประสิทธิภาพที่ดีขึ้นอย่างมีสไตล์

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

3. การกรองและการแปลงข้อมูลอย่างง่าย

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

สิ่งสำคัญคือต้องเข้าใจว่าเมื่อใดควรใช้ความเข้าใจในพจนานุกรมใน Python เนื่องจากอาจซับซ้อนขึ้นอย่างรวดเร็วและยากต่อการอ่านและเขียน ตอนนี้ เรามาสำรวจกรณีการใช้งานสำหรับความเข้าใจในพจนานุกรมใน Python กัน

3 ตัวอย่างของการใช้ความเข้าใจในพจนานุกรมเมื่อใด

ความเข้าใจมีประโยชน์ใน 3 สถานการณ์ต่อไปนี้:

1. เมื่อสร้างพจนานุกรมจากสองรายการ

{key:value for key, value in zip(list1, list2)}

2. เมื่อกรองพจนานุกรมตามค่า

{k: v for k, v in original_dict.items() if v > threshold}

3. เมื่อแปลงคีย์หรือค่า

{k.upper(): v * 2 for k, v in original_dict.items()}

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

มาดูข้อผิดพลาดที่พบบ่อยที่สุดเมื่อใช้ความเข้าใจในพจนานุกรม

ข้อผิดพลาดของความเข้าใจในพจนานุกรม

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

สร้างความสมดุลระหว่างความซับซ้อนและความสามารถในการอ่าน

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

ประสิทธิภาพด้วยชุดข้อมูลขนาดใหญ่

สำหรับชุดข้อมูลขนาดใหญ่ ความเข้าใจในพจนานุกรมอาจไม่เหมาะสมเสมอไป จากข้อมูลของStack Overflowตัวสร้าง dict() ในตัวสามารถทำงานได้ดีกว่าความเข้าใจในพจนานุกรมด้วยคู่คีย์-ค่าจำนวนมากเนื่องจากการวนซ้ำใน C

เปรียบเทียบกับวิธีอื่น

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

สำหรับลูป

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

ต่อไปนี้คือตัวอย่างการสร้างพจนานุกรมโดยใช้ for loop:

dictionary = {}
for key, value in zip(keys, values):
    dictionary[key] = value

ในทางกลับกัน ความเข้าใจในพจนานุกรมช่วยให้คุณได้ผลลัพธ์เดียวกันในบรรทัดเดียว:

dictionary = {key: value for key, value in zip(keys, values)}

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

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

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

ลองดูตัวอย่างฟังก์ชัน Lambda เพื่อสร้างพจนานุกรม:

keys = ['a', 'b', 'c']
values = [1, 2, 3]

key_value_pairs = map(lambda key, value: (key, value), keys, values)
dictionary = dict(key_value_pairs)

จากการเปรียบเทียบ ต่อไปนี้เป็นวิธีการสร้างพจนานุกรมเดียวกันโดยใช้ความเข้าใจ:

dictionary = {key: value for key, value in zip(keys, values)}

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

แนวทางปฏิบัติที่ดีที่สุดสำหรับความเข้าใจในพจนานุกรม

เมื่อใช้ความเข้าใจใน Python จำเป็นต้องปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดเพื่อปรับปรุงความสามารถในการอ่าน การบำรุงรักษา และประสิทธิภาพ แนวทางปฏิบัติที่ดีที่สุดที่ควรพิจารณามีดังนี้

1. ทำให้ความเข้าใจในพจนานุกรมเรียบง่าย

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

2. ใช้ประโยชน์จากฟังก์ชันในตัว

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

ตัวอย่างเช่น การใช้ zip() เพื่อรวมสองรายการเข้าด้วยกันและสร้างผลลัพธ์จากพจนานุกรมด้วยโค้ดที่กระชับและสะอาดดังนี้:

{key: value for key, value in zip(keys, values)}

3. ใช้ข้อความแสดงเงื่อนไขอย่างชาญฉลาด

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

{x: x**2 for x in range(10) if x % 2 == 0}

4. ระวังความเข้าใจในพจนานุกรมที่ซ้อนกัน

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

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

คำพูดสุดท้ายของเรา

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

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

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