ทำไมเราต้องใช้สิ่งอันดับใน Python (หรือชนิดข้อมูลที่ไม่เปลี่ยนรูปแบบ)

ฉันได้อ่านแบบฝึกหัด python หลายตัว (Dive Into Python สำหรับหนึ่ง) และการอ้างอิงภาษาบน Python.org - ฉันไม่เห็นว่าทำไมภาษาจึงต้องการสิ่งอันดับ

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

เปลี่ยนไม่ได้?

ทำไมทุกคนถึงสนใจว่าตัวแปรอาศัยอยู่ในที่ที่แตกต่างกันในความทรงจำมากกว่าตอนที่มันถูกจัดสรรไว้ในตอนแรก? ธุรกิจทั้งหมดของการเปลี่ยนแปลงไม่ได้ใน Python นี้ดูเหมือนจะเน้นมากกว่า

ใน C / C ++ ถ้าฉันจัดสรรตัวชี้และชี้ไปที่หน่วยความจำที่ใช้ได้ฉันไม่สนใจว่าที่อยู่นั้นอยู่ที่ไหนตราบใดที่มันไม่ว่างก่อนที่ฉันจะใช้

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

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

>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

x ยังคงอ้างอิงข้อมูลที่ฉันต้องการทำไมทุกคนต้องสนใจว่า id ของมันเหมือนกันหรือแตกต่างกันอย่างไร

1. วัตถุที่ไม่เปลี่ยนรูปสามารถปรับให้เหมาะสมอย่างมาก; นี่คือเหตุผลที่ว่าทำไมสตริงยังไม่เปลี่ยนรูปแบบใน Java พัฒนาค่อนข้างแยกจากกัน แต่ในเวลาเดียวกับ Python และเกือบทุกอย่างไม่เปลี่ยนแปลงในภาษาที่ใช้งานได้จริง

2. โดยเฉพาะอย่างยิ่งในงูหลาม immutables เท่านั้นสามารถ hashable (และดังนั้นสมาชิกของชุดหรือคีย์ในพจนานุกรม) อีกครั้งการปรับให้เหมาะสมนี้ แต่มากกว่า "สำคัญ" (การออกแบบตารางแฮชที่เหมาะสมที่จัดเก็บวัตถุที่ไม่แน่นอนอย่างสมบูรณ์นั้นเป็นฝันร้าย - ไม่ว่าคุณจะทำสำเนาทุกอย่างทันทีที่คุณแฮชหรือฝันร้ายของการตรวจสอบว่า มีการเปลี่ยนแปลงนับตั้งแต่คุณได้ทำการอ้างอิงไปแล้วมันจะเป็นการย้อนกลับไปที่หัวอันน่าเกลียดของมัน)

ตัวอย่างปัญหาการเพิ่มประสิทธิภาพ:

$ python -mtimeit '["fee", "fie", "fo", "fum"]'
1000000 loops, best of 3: 0.432 usec per loop
$ python -mtimeit '("fee", "fie", "fo", "fum")'
10000000 loops, best of 3: 0.0563 usec per loop

ไม่มีคำตอบข้างต้นชี้ให้เห็นถึงปัญหาที่แท้จริงของรายการ tuples vs ซึ่งดูเหมือนจะไม่เข้าใจอย่างสมบูรณ์

สิ่งอันดับและรายการมีจุดประสงค์ที่แตกต่างกัน แสดงรายการข้อมูลที่เป็นเนื้อเดียวกัน คุณสามารถและควรมีรายการดังนี้:

["Bob", "Joe", "John", "Sam"]

เหตุผลที่มีการใช้รายการที่ถูกต้องเพราะเป็นข้อมูลประเภทที่เป็นเนื้อเดียวกันโดยเฉพาะชื่อของผู้คน แต่ทำรายการดังนี้:

["Billy", "Bob", "Joe", 42]

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

[("Billy", "Bob", "Joe", 42), ("Robert", "", "Smith", 31)]

ความผันแปรไม่ได้และความไม่แน่นอนของ Tuples และรายการไม่แตกต่างหลัก รายการคือรายการของรายการประเภทเดียวกัน: ไฟล์ชื่อวัตถุ สิ่งอันดับคือการจัดกลุ่มของวัตถุประเภทต่างๆ พวกมันมีการใช้งานที่แตกต่างกันและรายการ Python coders ที่ใช้ในทางที่ผิดสำหรับสิ่งอันดับที่มีไว้สำหรับ

โปรดอย่า

แก้ไข:

ฉันคิดว่าโพสต์บล็อกนี้อธิบายว่าทำไมฉันจึงคิดว่าดีกว่านี้: http://news.e-scribe.com/397

หากฉันต้องแปลง tuple เป็น set หรือ list เพื่อให้สามารถเรียงลำดับได้จุดแรกที่ใช้ tuple คืออะไร

ในกรณีนี้อาจไม่มีประเด็น นี่ไม่ใช่ปัญหาเพราะนี่ไม่ใช่หนึ่งในกรณีที่คุณควรพิจารณาใช้ tuple

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

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

โปรดทราบว่าการใช้งาน Python โดยเฉพาะอาจไม่ได้ใช้ประโยชน์จากคุณสมบัติข้างต้นทั้งหมด

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

ดูเพิ่มเติม " tuples แนะนำ " จากดำน้ำลงในหลาม

บางครั้งเราชอบใช้วัตถุเป็นกุญแจพจนานุกรม

สำหรับสิ่งที่มีค่า tuples เมื่อเร็ว ๆ นี้ (2.6+) เติบโตindex()และcount()วิธีการ

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

ทำไมทุกคนถึงสนใจว่าตัวแปรอาศัยอยู่ในที่ที่แตกต่างกันในความทรงจำมากกว่าตอนที่มันถูกจัดสรรไว้ในตอนแรก? ธุรกิจทั้งหมดของการเปลี่ยนแปลงไม่ได้ใน Python นี้ดูเหมือนจะเน้นมากกว่า

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

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

>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

สิ่งนี้ไม่ได้แก้ไข ("การกลายพันธุ์") ตัวแปร; มันกำลังสร้างตัวแปรใหม่ที่มีชื่อเดียวกันและละทิ้งตัวแปรเก่า เปรียบเทียบกับการผ่าเหล่า:

>>> a = [1,2,3]
>>> id(a)
3084599212L
>>> a[1] = 5
>>> a
[1, 5, 3]
>>> id(a)
3084599212L

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

โปรดทราบว่าคีย์สำหรับพจนานุกรมไม่จำเป็นต้องไม่เปลี่ยนรูปแบบโดยสิ้นเชิง เฉพาะส่วนของมันที่ใช้เป็นกุญแจสำคัญที่จะต้องไม่เปลี่ยนรูป; สำหรับการใช้งานบางอย่างนี่เป็นข้อแตกต่างที่สำคัญ ตัวอย่างเช่นคุณอาจมีคลาสที่แสดงถึงผู้ใช้ซึ่งจะเปรียบเทียบความเท่าเทียมกันและแฮชด้วยชื่อผู้ใช้ที่ไม่ซ้ำกัน จากนั้นคุณสามารถแขวนข้อมูลที่ไม่แน่นอนอื่น ๆ ในชั้นเรียน - "ผู้ใช้ลงชื่อเข้าใช้" เป็นต้นเนื่องจากสิ่งนี้ไม่ส่งผลกระทบต่อความเท่าเทียมกันหรือแฮชจึงเป็นไปได้และสมบูรณ์ที่จะใช้สิ่งนี้เป็นกุญแจสำคัญในพจนานุกรม สิ่งนี้ไม่จำเป็นใน Python ฉันเพิ่งจะชี้ให้เห็นเพราะหลายคนอ้างว่ากุญแจต้องเป็น "ไม่เปลี่ยนรูป" ซึ่งถูกต้องเพียงบางส่วนเท่านั้น ฉันใช้หลายครั้งกับแผนที่และชุด C ++

ดังที่ gnibbler เสนอในความคิดเห็น Guido มีความเห็นที่ไม่ยอมรับ / ชื่นชมอย่างเต็มที่:“ รายการนี้มีไว้สำหรับข้อมูลที่เป็นเนื้อเดียวกันและสิ่งอันดับจะเป็นข้อมูลที่ต่างกัน” แน่นอนว่าผู้ต่อต้านหลายคนตีความสิ่งนี้ว่าเป็นความหมายว่าองค์ประกอบทั้งหมดของรายการควรเป็นประเภทเดียวกัน

ฉันชอบที่จะเห็นมันแตกต่างกันไม่เหมือนคนอื่น ๆในอดีต:

blue= 0, 0, 255
alist= ["red", "green", blue]

โปรดทราบว่าฉันถือว่าอลิสต์เป็นเนื้อเดียวกันแม้ว่าจะเป็นประเภท (alist [1])! = type (alist [2])

หากฉันสามารถเปลี่ยนลำดับขององค์ประกอบและฉันจะไม่มีปัญหาในรหัสของฉัน (นอกเหนือจากสมมติฐานเช่น "ควรจะเรียงลำดับ") จากนั้นควรใช้รายการ ถ้าไม่ใช่ (เหมือนใน tuple blueด้านบน) ดังนั้นฉันควรใช้ tuple

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

a = [1,1,1]
doWork(a)

โทรมีการรับประกันของมูลค่าของไม่มีหลังจากที่โทร อย่างไรก็ตาม

a = (1,1,1)
doWorK(a)

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

คุณสามารถดูที่นี่สำหรับการสนทนาเกี่ยวกับเรื่องนี้

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

ก่อนที่เราจะดำเนินการตรวจสอบให้แน่ใจว่าพฤติกรรมที่แสดงด้านล่างนี้เป็นสิ่งที่คุณคาดหวังจาก Python

>>> a1 = [1]
>>> a2 = a1
>>> print a2[0]
1
>>> a1[0] = 2
>>> print a2[0]
2

ในกรณีนี้เนื้อหาของ a2 มีการเปลี่ยนแปลงแม้ว่าจะมีเพียง a1 เท่านั้นที่มีการกำหนดค่าใหม่ ตรงกันข้ามกับสิ่งต่อไปนี้:

>>> a1 = (1,)
>>> a2 = a1
>>> print a2[0]
1
>>> a1 = (2,)
>>> print a2[0]
1

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

เหตุใดเรื่องนี้ สมมติว่าคุณมีพจน์:

>>> t1 = (1,2)
>>> d1 = { t1 : 'three' }
>>> print d1
{(1,2): 'three'}
>>> t1[0] = 0  ## results in a TypeError, as tuples cannot be modified
>>> t1 = (2,3) ## creates a new tuple, does not modify the old one
>>> print d1   ## as seen here, the dict is still intact
{(1,2): 'three'}

การใช้ tuple ทำให้พจนานุกรมปลอดภัยจากการเปลี่ยนคีย์ "ออกจากใต้" เป็นรายการที่แฮชเป็นค่าอื่น นี่เป็นสิ่งสำคัญที่จะช่วยให้การใช้งานมีประสิทธิภาพ