วัตถุมุมมองพจนานุกรมคืออะไร?

ใน python 2.7 เรามีวิธีการดูพจนานุกรมที่มีอยู่

ตอนนี้ฉันรู้ข้อดีและข้อเสียของสิ่งต่อไปนี้:

• dict.items()(และvalues, keys): ส่งคืนรายการดังนั้นคุณจึงสามารถจัดเก็บผลลัพธ์ได้จริงและ
• dict.iteritems() (และชอบ): ส่งคืนตัวสร้างดังนั้นคุณสามารถวนซ้ำแต่ละค่าที่สร้างทีละตัว

อะไรคือสิ่งที่dict.viewitems()และชอบ ประโยชน์ของพวกเขาคืออะไร? มันทำงานยังไง? อะไรคือมุมมองหลังจากทั้งหมด?

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

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

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> keys  # No eggs anymore!
dict_keys(['sausage', 'bacon', 'spam'])

>>> values  # No eggs value (2) anymore!
dict_values([1, 1, 500])

(การใช้ Python 2 ที่เทียบเท่าdishes.viewkeys()และdishes.viewvalues().)

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

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

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

ดังที่คุณกล่าวถึงdict.items()จะส่งคืนสำเนาของรายการของคู่ (คีย์, ค่า) ซึ่งสิ้นเปลืองและdict.iteritems()ส่งคืนตัววนซ้ำของคู่ (คีย์, ค่า) ของพจนานุกรม

ตอนนี้ใช้ตัวอย่างต่อไปนี้เพื่อดูความแตกต่างระหว่างตัวคั่นของ dict และมุมมองของ dict

>>> d = {"x":5, "y":3}
>>> iter = d.iteritems()
>>> del d["x"]
>>> for i in iter: print i
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: dictionary changed size during iteration

ในขณะที่มุมมองเพียงแสดงให้คุณเห็นสิ่งที่อยู่ใน Dict มันไม่สนใจว่ามันจะเปลี่ยนไปหรือไม่:

>>> d = {"x":5, "y":3}
>>> v = d.viewitems()
>>> v
dict_items([('y', 3), ('x', 5)])
>>> del d["x"]
>>> v
dict_items([('y', 3)])

มุมมองเป็นเพียงสิ่งที่พจนานุกรมดูเหมือนว่าตอนนี้ หลังจากลบรายการ.items()จะล้าสมัยและ.iteritems()มีข้อผิดพลาดเกิดขึ้น

เพียงแค่อ่านเอกสารฉันได้รับความประทับใจนี้:

1. มุมมองคือ "หลอกเหมือนชุด" ซึ่งพวกเขาไม่สนับสนุนการจัดทำดัชนีดังนั้นสิ่งที่คุณสามารถทำได้คือทดสอบการเป็นสมาชิกและวนซ้ำไปเรื่อย ๆ (เพราะคีย์มีการแฮชและไม่ซ้ำกันมุมมองคีย์และรายการมีมากกว่า " set-like "ที่พวกเขาไม่มีรายการซ้ำกัน)
2. คุณสามารถจัดเก็บและใช้งานได้หลายครั้งเช่นเวอร์ชันรายการ
3. เนื่องจากมันสะท้อนถึงพจนานุกรมพื้นฐานการเปลี่ยนแปลงใด ๆ ในพจนานุกรมจะเปลี่ยนมุมมองและจะเปลี่ยนลำดับการวนซ้ำอย่างแน่นอน ซึ่งแตกต่างจากเวอร์ชันของรายการพวกเขาไม่ "เสถียร"
4. เพราะมันสะท้อนถึงพจนานุกรมพื้นฐานพวกมันเกือบจะเป็นวัตถุพร็อกซี่เล็ก ๆ การคัดลอกคีย์ / ค่า / ไอเท็มจะต้องให้พวกเขาดูพจนานุกรมต้นฉบับอย่างใดและคัดลอกหลายครั้งเมื่อมีการเปลี่ยนแปลงเกิดขึ้นซึ่งจะเป็นการใช้งานที่ไร้สาระ ดังนั้นฉันคาดหวังค่าใช้จ่ายหน่วยความจำน้อยมาก แต่การเข้าถึงช้ากว่าพจนานุกรมโดยตรงเล็กน้อย

ดังนั้นฉันจึงเดาว่าการใช้คีย์คือถ้าคุณเก็บพจนานุกรมไว้และวนซ้ำ ๆ ซ้ำ ๆ คีย์ / ไอเท็ม / ค่าที่มีการปรับเปลี่ยนในระหว่างนั้น คุณก็สามารถใช้มุมมองแทนที่จะหันเข้าfor k, v in mydict.iteritems(): for k, v in myview:แต่ถ้าคุณแค่วนซ้ำพจนานุกรมหนึ่งครั้งฉันคิดว่ารุ่นตัวเลือกยังดีกว่า

มุมมองวิธีการกลับรายการ (ไม่สำเนาของรายการเมื่อเทียบกับ.keys(), .items()และ.values()) ดังนั้นจึงมีน้ำหนักเบามากขึ้น แต่สะท้อนให้เห็นถึงเนื้อหาปัจจุบันของพจนานุกรม

จากPython 3.0 - เมธอด dict ส่งคืนมุมมอง - เพราะอะไร

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

หากคุณต้องการทำซ้ำคีย์มากกว่าการสร้างรายการใหม่ก็ไม่จำเป็น และถ้าคุณต้องการมันเป็นรายการแยกต่างหาก (เป็นสำเนา) คุณสามารถสร้างรายการนั้นจากมุมมองได้อย่างง่ายดาย

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

ตัวเลือกที่หนึ่งคือการสร้างรายการคีย์ที่ใช้dict.keys()งานได้ แต่เห็นได้ชัดว่าต้องใช้หน่วยความจำมากขึ้น ถ้า dict มีขนาดใหญ่มาก? นั่นจะสิ้นเปลือง

ด้วยviewsคุณสามารถทำซ้ำโครงสร้างข้อมูลจริงโดยไม่ต้องรายการกลาง

ลองใช้ตัวอย่าง ฉันเขียนตามตัวเลขและสตริงแบบสุ่ม 1,000 คีย์และkเป็นกุญแจที่ฉันต้องการค้นหา

large_d = { .. 'NBBDC': '0RMLH', 'E01AS': 'UAZIQ', 'G0SSL': '6117Y', 'LYBZ7': 'VC8JQ' .. }

>>> len(large_d)
1000

# this is one option; It creates the keys() list every time, it's here just for the example
timeit.timeit('k in large_d.keys()', setup='from __main__ import large_d, k', number=1000000)
13.748743600954867


# now let's create the list first; only then check for containment
>>> list_keys = large_d.keys()
>>> timeit.timeit('k in list_keys', setup='from __main__ import large_d, k, list_keys', number=1000000)
8.874809793833492


# this saves us ~5 seconds. Great!
# let's try the views now
>>> timeit.timeit('k in large_d.viewkeys()', setup='from __main__ import large_d, k', number=1000000)
0.08828549011070663

# How about saving another 8.5 seconds?

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

หมายเหตุ : ฉันกำลังใช้งาน Python 2.7