ความแตกต่างระหว่างรายการและสิ่งอันดับคืออะไร

ความแตกต่างคืออะไร?

อะไรคือข้อดี / ข้อเสียของสิ่งอันดับ / รายการ

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

การใช้ความแตกต่างนี้ทำให้โค้ดชัดเจนและเข้าใจได้ง่ายขึ้น

ตัวอย่างหนึ่งคือคู่ของหน้าและหมายเลขบรรทัดเพื่ออ้างอิงตำแหน่งในหนังสือเช่น:

my_location = (42, 11)  # page number, line number

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

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

มีบางบทความที่น่าสนใจเกี่ยวกับปัญหานี้เช่น"งูใหญ่ Tuples ไม่เพียงรายการคงที่"หรือ"tuples เข้าใจกับรายชื่อในงูใหญ่" เอกสารไพ ธ อนอย่างเป็นทางการยังกล่าวถึงสิ่งนี้

"ทูเปิลนั้นไม่เปลี่ยนรูปและมักจะมีลำดับที่ต่างกัน ... "

ในภาษาที่พิมพ์แบบคงที่เช่นHaskellค่าใน tuple โดยทั่วไปจะมีประเภทที่แตกต่างกันและความยาวของ tuple จะต้องได้รับการแก้ไข ในรายการค่าทั้งหมดมีชนิดเดียวกันและความยาวไม่คงที่ ดังนั้นความแตกต่างจึงชัดเจนมาก

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

ความแตกต่างระหว่างรายการและทูเปิล

1. ตามตัวอักษร

   someTuple = (1,2)
   someList  = [1,2] 

2. ขนาด

   a = tuple(range(1000))
   b = list(range(1000))
   
   a.__sizeof__() # 8024
   b.__sizeof__() # 9088

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

3. การดำเนินงานที่ได้รับอนุญาต

   b    = [1,2]   
   b[0] = 3       # [3, 2]
   
   a    = (1,2)
   a[0] = 3       # Error

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

   a     = (1,2)
   b     = [1,2]  
   
   id(a)          # 140230916716520
   id(b)          # 748527696
   
   a   += (3,)    # (1, 2, 3)
   b   += [3]     # [1, 2, 3]
   
   id(a)          # 140230916878160
   id(b)          # 748527696

4. การใช้

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

   a    = (1,2)
   b    = [1,2] 
   
   c = {a: 1}     # OK
   c = {b: 1}     # Error

หากคุณไปเดินเล่นคุณสามารถบันทึกพิกัดของคุณได้ทันทีในสิ่ง(x,y)อันดับ

หากคุณต้องการบันทึกการเดินทางของคุณคุณสามารถผนวกตำแหน่งของคุณทุก ๆ วินาทีในรายการ

แต่คุณไม่สามารถทำแบบนี้ได้

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

ดังนั้นหากคุณจะต้องเปลี่ยนค่าใช้รายการ

ประโยชน์ที่จะ tuples:

1. การปรับปรุงประสิทธิภาพเล็กน้อย
2. ในฐานะที่เป็น tuple ไม่เปลี่ยนรูปก็สามารถใช้เป็นกุญแจสำคัญในพจนานุกรม
3. หากคุณไม่สามารถเปลี่ยนแปลงได้ไม่ว่าใครก็สามารถบอกได้ว่าคุณไม่จำเป็นต้องกังวลเกี่ยวกับฟังก์ชั่น API ใด ๆ ฯลฯ การเปลี่ยน tuple ของคุณโดยไม่ถูกถาม

รายการไม่แน่นอน สิ่งอันดับไม่

จากdocs.python.org/2/tutorial/datastructures.html

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

มีการกล่าวถึงความแตกต่างที่มีความหมายส่วนใหญ่: ผู้คนคาดหวังสิ่งอันดับและรายการเพื่อแสดงข้อมูลที่แตกต่างกัน แต่สิ่งนี้ยิ่งไปกว่าแนวทาง ห้องสมุดบางแห่งมีพฤติกรรมแตกต่างกันไปตามสิ่งที่พวกเขาส่งผ่าน ยกตัวอย่าง NumPy (คัดลอกมาจากโพสต์อื่นที่ฉันขอตัวอย่างเพิ่มเติม):

>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
       [3, 4, 5]])

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

รายการมีการวนลูป, "%s %s" %tupleสิ่งอันดับสำหรับโครงสร้างเช่น

รายการมักจะเป็นเนื้อเดียวกัน tuples มักจะต่างกัน

รายการมีความยาวผันแปรได้สิ่งอันดับเป็นความยาวคงที่

นี่คือตัวอย่างของรายการ Python:

my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

นี่คือตัวอย่างของ Python tuple:

my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

รายการไพ ธ อนและสิ่งอันดับคล้ายกันว่าทั้งคู่เป็นชุดของค่าที่เรียงลำดับ นอกจากความแตกต่างตื้น ๆ ที่มีการสร้างรายการโดยใช้วงเล็บ "[... , ... ]" และสิ่งอันดับโดยใช้วงเล็บ "(... , ... )", หลักทางเทคนิค "รหัสยากในไวยากรณ์หลาม" ความแตกต่างระหว่างพวกเขา คือองค์ประกอบของ tuple นั้นไม่เปลี่ยนแปลงในขณะที่รายการต่าง ๆ ไม่แน่นอน (... ดังนั้น tuples เท่านั้นที่สามารถแฮชและสามารถใช้เป็น dictionary / hash keys!) นี้จะทำให้เกิดความแตกต่างในวิธีที่พวกเขาสามารถหรือไม่สามารถใช้ (บังคับเบื้องต้นโดยไวยากรณ์) และความแตกต่างในวิธีการที่คนเลือกที่จะใช้พวกเขา (ได้รับการสนับสนุนเป็น 'ปฏิบัติที่ดีที่สุด' posteriori นี้เป็นสิ่งที่สมาร์ท programers ทำ) คนให้ลำดับขององค์ประกอบ

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

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

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

เพื่อสรุปรายละเอียดปลีกย่อยบางส่วน

ความคล้ายคลึงกัน:

1. รายการที่ซ้ำกัน - ทั้ง tuples และรายการอนุญาตสำหรับการทำซ้ำ

2. การทำดัชนีการเลือกและการแบ่งส่วน - ทั้งดัชนีอันดับและรายการโดยใช้ค่าจำนวนเต็มที่พบภายในวงเล็บ ดังนั้นหากคุณต้องการ 3 ค่าแรกของรายการหรือ tuple ที่กำหนดไวยากรณ์จะเหมือนกัน:

   >>> my_list[0:3]
   [0,1,2]
   >>> my_tuple[0:3]
   [a,b,c]

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

   >>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
   True
   >>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
   True

ความแตกต่าง: - นิรนัยตามคำนิยาม

1. ไวยากรณ์ - รายการใช้ [], สิ่งอันดับใช้ ()

2. ความไม่แน่นอน - องค์ประกอบในรายการที่กำหนดจะไม่แน่นอนองค์ประกอบใน tuple ที่กำหนดไม่สามารถเปลี่ยนแปลงได้

   # Lists are mutable:
   >>> top_rock_list
   ['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
   >>> top_rock_list[1]
   'Kashmir'
   >>> top_rock_list[1] = "Stairway to Heaven"
   >>> top_rock_list
   ['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']
   
   # Tuples are NOT mutable:       
   >>> celebrity_tuple
   ('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
   >>> celebrity_tuple[5]
   'Dead'
   >>> celebrity_tuple[5]="Alive"
   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   TypeError: 'tuple' object does not support item assignment

3. Hashtables (พจนานุกรม) - เนื่องจาก hashtables (พจนานุกรม) ต้องการให้คีย์ของมันนั้น hashable และไม่เปลี่ยนรูปดังนั้นมีเพียง tuples เท่านั้นที่สามารถทำหน้าที่เป็นปุ่มพจนานุกรมได้

   #Lists CAN'T act as keys for hashtables(dictionaries)
   >>> my_dict = {[a,b,c]:"some value"}
   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   TypeError: unhashable type: 'list'
   
   #Tuples CAN act as keys for hashtables(dictionaries)
   >>> my_dict = {("John","Wayne"): 90210}
   >>> my_dict
   {('John', 'Wayne'): 90210}

ความแตกต่าง - หลังการใช้งาน

1. Homo vs. Heterogeneity of Elements - โดยทั่วไปวัตถุในรายการเป็นวัตถุที่เป็นเนื้อเดียวกันและสิ่งอันดับเป็นแบบ heterogeneous นั่นคือรายการจะใช้สำหรับวัตถุ / อาสาสมัครประเภทเดียวกัน (เช่นผู้สมัครชิงตำแหน่งประธานาธิบดีหรือเพลงทั้งหมดหรือนักวิ่งทั้งหมด) ในขณะที่แม้ว่ามันจะไม่ได้ถูกบังคับโดย) ในขณะที่สิ่งอันดับสำหรับวัตถุที่ต่างกัน

2. การวนลูปเทียบกับโครงสร้าง - แม้ว่าทั้งคู่จะอนุญาตให้วนซ้ำ (สำหรับ x ใน my_list ... ), จริง ๆ แล้วมันสมเหตุสมผลที่จะทำสำหรับรายการเท่านั้น Tuples เหมาะสมกว่าสำหรับการจัดโครงสร้างและการนำเสนอข้อมูล (% s% s ที่อยู่ใน% s คือ% s และ% s% ในปัจจุบัน ("John", "Wayne", 90210, "Actor", "Dead")

ค่าของรายการสามารถเปลี่ยนแปลงได้ตลอดเวลา แต่ค่าของสิ่งอันดับจะไม่สามารถเปลี่ยนแปลงได้

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

ความแตกต่างระหว่างรายการและทูเปิล

สิ่งอันดับและรายการมีทั้งประเภทลำดับที่คล้ายกันใน Python

1. ไวยากรณ์ตัวอักษร

   เราใช้วงเล็บ ( ) เพื่อสร้างสิ่งอันดับและวงเล็บเหลี่ยม[ ]เพื่อรับรายการใหม่ นอกจากนี้เราสามารถใช้การเรียกประเภทที่เหมาะสมเพื่อรับโครงสร้างที่ต้องการ - tuple หรือรายการ

   someTuple = (4,6)
   someList  = [2,6] 

2. ความไม่แน่นอน

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

3. การใช้ความจำ

   เนื่องจากความไม่แน่นอนคุณต้องการหน่วยความจำเพิ่มเติมสำหรับรายการและหน่วยความจำน้อยสำหรับ tuples

4. ขยาย

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

5. คร่ำเครียด

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

   tup      = (1,2)
   list_    = [1,2] 
   
   c = {tup   : 1}     # ok
   c = {list_ : 1}     # error

6. อรรถศาสตร์

   ประเด็นนี้เกี่ยวกับการปฏิบัติที่ดีที่สุด คุณควรใช้สิ่งอันดับเป็นโครงสร้างข้อมูลที่ต่างกันในขณะที่รายการต่าง ๆ เป็นเนื้อเดียวกัน

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

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

ถ้าtuplea listหรือ a dictionaryข้างในนั้นมันสามารถเปลี่ยนได้แม้ว่าtupleตัวมันเองจะไม่เปลี่ยนรูปก็ตาม

ตัวอย่างเช่นสมมติว่าเรามีสิ่งอันดับที่มีรายการและพจนานุกรมเป็น

my_tuple = (10,20,30,[40,50],{ 'a' : 10})

เราสามารถเปลี่ยนเนื้อหาของรายการเป็น

my_tuple[3][0] = 400
my_tuple[3][1] = 500

ซึ่งทำให้ tuple ใหม่ดูเหมือน

(10, 20, 30, [400, 500], {'a': 10})

เรายังสามารถเปลี่ยนพจนานุกรมภายใน tuple เป็น

my_tuple[4]['a'] = 500

ซึ่งจะทำให้ tuple โดยรวมดูเหมือนว่า

(10, 20, 30, [400, 500], {'a': 500})

สิ่งนี้เกิดขึ้นเพราะlistและdictionaryเป็นวัตถุและวัตถุเหล่านี้จะไม่เปลี่ยนแปลง แต่เนื้อหาที่ชี้ไป

ดังนั้นสิ่งที่tupleเหลือไว้ไม่เปลี่ยนแปลงโดยไม่มีข้อยกเว้น

PEP 484 - ประเภทคำแนะนำบอกว่าประเภทขององค์ประกอบของที่tupleสามารถพิมพ์รายบุคคล เพื่อให้คุณสามารถพูดTuple[str, int, float]; แต่listด้วยListคลาสการพิมพ์สามารถใช้พารามิเตอร์ประเภทเดียวเท่านั้น: List[str]ซึ่งบอกเป็นนัยว่าความแตกต่างของ 2 คือจริง ๆ ว่าอดีตคือต่างกันในขณะที่หลังเป็นเนื้อเดียวกัน

นอกจากนี้มาตรฐานห้องสมุดส่วนใหญ่ใช้ tuple structเป็นค่าตอบแทนจากฟังก์ชั่นมาตรฐานเช่นที่ซีจะกลับมาเป็น

อย่างที่ผู้คนพูดถึงความแตกต่างแล้วฉันจะเขียนว่าทำไมสิ่งอันดับ

ทำไมเป็นสิ่งอันดับ tuples?

การเพิ่มประสิทธิภาพการจัดสรรสำหรับ tuples ขนาดเล็ก

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

รายการฟรีแบ่งออกเป็น 20 กลุ่มโดยที่แต่ละกลุ่มแสดงรายการของสิ่งอันดับความยาว n ระหว่าง 0 ถึง 20 แต่ละกลุ่มสามารถเก็บได้มากถึง 2 000 tuples กลุ่มแรก (ศูนย์) มีเพียง 1 องค์ประกอบและแสดงถึง tuple ที่ว่างเปล่า

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

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

การเพิ่มประสิทธิภาพการจัดสรรสำหรับรายการ

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

>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

ที่มา: https://rushter.com/blog/python-lists-and-tuples/

ทำไมสิ่งอันดับมีประสิทธิภาพมากกว่ารายการ -> https://stackoverflow.com/a/22140115

ใบเสนอราคาทิศทางจากเอกสารประกอบในข้อ5.3 สิ่งอันดับและลำดับ :

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

ประการแรกพวกเขาทั้งคู่เป็นวัตถุที่ไม่ใช่สเกลาร์ (หรือที่รู้จักกันว่าวัตถุผสม) ใน Python

• Tuples เรียงลำดับองค์ประกอบ (ซึ่งสามารถมีวัตถุใด ๆ ที่ไม่มีปัญหาเรื่อง aliasing)
  • ไม่เปลี่ยนรูป (tuple, int, float, str)
  • การต่อเชื่อมโดยใช้+(สร้าง tuple ใหม่เอี่ยมแน่นอน)
  • การจัดทำดัชนี
  • หั่น
  • ซิงเกิล(3,) # -> (3)แทน(3) # -> 3
• รายการ (Array ในภาษาอื่น ๆ ) ลำดับของค่าที่สั่ง
  • ไม่แน่นอน
  • ซิงเกิล [3]
  • โคลน new_array = origin_array[:]
  • รายการความเข้าใจ[x**2 for x in range(1,7)]ให้คุณ [1,4,9,16,25,36](อ่านไม่ได้)

การใช้รายการอาจทำให้เกิดข้อผิดพลาดในนามแฝง (เส้นทางที่แตกต่างกันสองเส้นทางที่ชี้ไปยังวัตถุเดียวกัน)

รายการไม่แน่นอนและสิ่งอันดับจะเปลี่ยนรูป ลองพิจารณาตัวอย่างนี้

a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #tuple

ตอนนี้เปลี่ยนค่าดัชนีของรายการและ tuple

a[2] = 1000
print a     #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b     #output : TypeError: 'tuple' object does not support item assignment.

ดังนั้นจึงพิสูจน์ได้ว่ารหัสต่อไปนี้ไม่ถูกต้องสำหรับสิ่งอันดับเนื่องจากเราพยายามอัปเดตสิ่งอันดับซึ่งไม่ได้รับอนุญาต

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

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

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