Python Language => सूची

परिचय

अजगर सूची एक सामान्य डेटा संरचना है जिसका व्यापक रूप से पायथन कार्यक्रमों में उपयोग किया जाता है। वे अन्य भाषाओं में पाए जाते हैं, जिन्हें अक्सर गतिशील सरणियों के रूप में जाना जाता है। वे दोनों परिवर्तनशील और एक अनुक्रम डेटा प्रकार हैं जो उन्हें अनुक्रमित और कटा हुआ करने की अनुमति देता है। सूची में अन्य सूची वस्तुओं सहित विभिन्न प्रकार की वस्तुएं हो सकती हैं।

वाक्य - विन्यास

[मूल्य, मूल्य, ...]
सूची ([iterable])

टिप्पणियों

list एक विशेष प्रकार का चलने योग्य है, लेकिन यह एकमात्र ऐसा नहीं है जो पायथन में मौजूद है। कभी-कभी set , tuple या dictionary का उपयोग करना बेहतर होगा

list पायथन में डायनामिक एरेज़ ( vector<void*> समान) C ++ या जावा के ArrayList<Object> ) से दी गई है। यह लिंक्ड-लिस्ट नहीं है।

तत्वों को एक्सेस करना निरंतर समय में किया जाता है और बहुत तेज होता है। सूची के अंत में तत्वों को लागू करना निरंतर समय में परिशोधन है, लेकिन एक समय में एक बार इसमें संपूर्ण list का आवंटन और प्रतिलिपि शामिल हो सकती है।

सूची समझ सूची से संबंधित हैं।

सूची मूल्यों तक पहुँचना

पायथन सूचियाँ शून्य-अनुक्रमित हैं, और अन्य भाषाओं में सरणियों की तरह काम करती हैं।

lst = [1, 2, 3, 4]
lst[0]  # 1
lst[1]  # 2

सूची की सीमा के बाहर एक सूचकांक का उपयोग करने का प्रयास एक IndexError बढ़ाएगा।

lst[4]  # IndexError: list index out of range

नकारात्मक सूचकांकों को सूची के अंत से गिनती के रूप में व्याख्या की जाती है।

lst[-1]  # 4
lst[-2]  # 3
lst[-5]  # IndexError: list index out of range

यह कार्यात्मक रूप से इसके बराबर है

lst[len(lst)-1]  # 4

सूचियाँ lst[start:end:step] रूप में स्लाइस नोटेशन का उपयोग करने की अनुमति देती हैं lst[start:end:step] । स्लाइस नोटेशन का आउटपुट एक नई सूची है जिसमें इंडेक्स start लेकर end-1 तत्व शामिल हैं। यदि विकल्प सूची की शुरुआत के लिए चूक start जाते हैं, तो सूची का अंत और step 1 तक end हो जाएगा:

lst[1:]      # [2, 3, 4]
lst[:3]      # [1, 2, 3]
lst[::2]     # [1, 3]
lst[::-1]    # [4, 3, 2, 1] 
lst[-1:0:-1] # [4, 3, 2]
lst[5:8]     # [] since starting index is greater than length of lst, returns empty list
lst[1:10]    # [2, 3, 4] same as omitting ending index

इसे ध्यान में रखते हुए, आप कॉल करके सूची का उलटा संस्करण मुद्रित कर सकते हैं

lst[::-1]    # [4, 3, 2, 1]

ऋणात्मक राशियों की चरण लंबाई का उपयोग करते समय, शुरुआती सूचकांक को समाप्त सूचकांक से अधिक होना चाहिए अन्यथा परिणाम एक खाली सूची होगी।

lst[3:1:-1] # [4, 3]

नकारात्मक चरण सूचकांकों का उपयोग करना निम्न कोड के बराबर है:

reversed(lst)[0:2] # 0 = 1 -1
                   # 2 = 3 -1

उपयोग किए गए सूचकांक नकारात्मक अनुक्रमण में उपयोग किए जाने वाले की तुलना में 1 कम हैं और उलट हैं।

उन्नत टुकड़ा करना

जब सूचियों को __getitem__() कटा जाता है तो सूची ऑब्जेक्ट की विधि को एक slice ऑब्जेक्ट के साथ कहा जाता है। पायथन में स्लाइस ऑब्जेक्ट बनाने के लिए एक बिलिन स्लाइस विधि है। हम इसका उपयोग एक स्लाइस को स्टोर करने और बाद में पुनः उपयोग करने के लिए कर सकते हैं,

data = 'chandan purohit    22 2000'  #assuming data fields of fixed length 
name_slice = slice(0,19)
age_slice = slice(19,21)
salary_slice = slice(22,None)

#now we can have more readable slices
print(data[name_slice]) #chandan purohit     
print(data[age_slice]) #'22'
print(data[salary_slice]) #'2000'

यह हमारी कक्षा में __getitem__ को ओवरराइड करके हमारी वस्तुओं को कार्यशील कार्यक्षमता प्रदान करके बहुत काम आ सकता है।

सूची विधियों और समर्थित ऑपरेटरों

दी गई सूची a शुरू करना:

a = [1, 2, 3, 4, 5]

append(value) - सूची के अंत में एक नया तत्व जोड़ता है।
```
# Append values 6, 7, and 7 to the list
a.append(6)
a.append(7)
a.append(7)
# a: [1, 2, 3, 4, 5, 6, 7, 7]

# Append another list
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]

# Append an element of a different type, as list elements do not need to have the same type
my_string = "hello world"
a.append(my_string)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]
```
ध्यान दें कि append() विधि केवल सूची के अंत में एक नया तत्व जोड़ता है। यदि आप किसी सूची को किसी अन्य सूची में जोड़ते हैं, तो आप जिस सूची को जोड़ते हैं वह पहली सूची के अंत में एक तत्व बन जाती है।
```
# Appending a list to another list
a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
a[8]
# Returns: [8,9]
```
extend(enumerable) - एक और गणना योग्य से तत्वों को जोड़कर सूची का विस्तार करता है।
```
a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9, 10]

# Extend list by appending all elements from b
a.extend(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

# Extend list with elements from a non-list enumerable:
a.extend(range(3))
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]
```
सूचियों को + ऑपरेटर के साथ भी समेटा जा सकता है। ध्यान दें कि यह किसी भी मूल सूची को संशोधित नहीं करता है:
```
a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
```
index(value, [startIndex]) - इनपुट मूल्य की पहली घटना का सूचकांक प्राप्त करता है। यदि इनपुट मान सूची में नहीं है, तो एक ValueError अपवाद उठाया गया है। यदि दूसरा तर्क प्रदान किया जाता है, तो खोज उस निर्दिष्ट सूचकांक पर शुरू की जाती है।
```
a.index(7)
# Returns: 6

a.index(49) # ValueError, because 49 is not in a.

a.index(7, 7)
# Returns: 7

a.index(7, 8) # ValueError, because there is no 7 starting at index 8
```

insert(index, value) - आवेषण value सिर्फ निर्दिष्ट से पहले index । इस प्रकार सम्मिलन के बाद नया तत्व स्थिति index कब्जा कर लेता है।
```
a.insert(0, 0)  # insert 0 at position 0
a.insert(2, 5)  # insert 5 at position 2
# a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
```

pop([index]) - आइटम को index पर निकालता है और लौटाता है। बिना किसी तर्क के यह सूची के अंतिम तत्व को निकालता है और वापस करता है।
```
a.pop(2)
# Returns: 5
# a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
a.pop(8)
# Returns: 7
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# With no argument:
a.pop()
# Returns: 10
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```
remove(value) - निर्दिष्ट मूल्य की पहली घटना को हटाता है। यदि प्रदान किया गया मान नहीं पाया जा सकता है, तो एक ValueError उठाया जाता है।
```
a.remove(0)
a.remove(9)
# a: [1, 2, 3, 4, 5, 6, 7, 8]
a.remove(10)
# ValueError, because 10 is not in a
```
reverse() - सूची को जगह में उलट देता है और None लौटाता है।
```
a.reverse()
# a: [8, 7, 6, 5, 4, 3, 2, 1]
```
किसी सूची को उलटने के अन्य तरीके भी हैं।
count(value) - सूची में कुछ मूल्य की घटनाओं की संख्या को गिना जाता है।
```
a.count(7)
# Returns: 2
```

sort() - सूची को संख्यात्मक और लेक्सिकोग्राफ़िक क्रम में क्रमबद्ध करें और None लौटाता।

a.sort()
# a = [1, 2, 3, 4, 5, 6, 7, 8]
# Sorts the list in numerical order

जब क्रमबद्ध sort() विधि में reverse=True झंडे का उपयोग करके सूची को उलटा किया जा सकता है।

a.sort(reverse=True)
# a = [8, 7, 6, 5, 4, 3, 2, 1]

यदि आप आइटम की विशेषताओं के आधार पर क्रमबद्ध करना चाहते हैं, तो आप key कीवर्ड तर्क का उपयोग कर सकते हैं:

import datetime

class Person(object):
    def __init__(self, name, birthday, height):
        self.name = name
        self.birthday = birthday
        self.height = height

    def __repr__(self):
        return self.name

l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
     Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
     Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]

l.sort(key=lambda item: item.name)
# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item.birthday)
# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item.height)
# l: [John Cena, Chuck Norris, Jon Skeet]

Dicts की सूची के मामले में अवधारणा समान है:

import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
 {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
 {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]

l.sort(key=lambda item: item['name'])
# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item['birthday'])
# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]

उप तानाशाही के आधार पर छाँटें:

import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
 {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
 {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]

l.sort(key=lambda item: item['size']['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]

attrgetter और itemgetter का उपयोग करके सॉर्ट करने का बेहतर तरीका

ऑपरेटर मॉड्यूल से attrgetter और itemgetter फ़ंक्शन का उपयोग करके सूचियों को भी सॉर्ट किया जा सकता है। ये पठनीयता और पुन: प्रयोज्य को बेहतर बनाने में मदद कर सकते हैं। यहाँ कुछ उदाहरण हैं,

from operator import itemgetter,attrgetter

people = [{'name':'chandan','age':20,'salary':2000},
          {'name':'chetan','age':18,'salary':5000},
          {'name':'guru','age':30,'salary':3000}]
by_age = itemgetter('age')
by_salary = itemgetter('salary')

people.sort(key=by_age) #in-place sorting by age
people.sort(key=by_salary) #in-place sorting by salary

itemgetter को एक इंडेक्स भी दिया जा सकता है। यदि आप एक ट्यूल के सूचकांकों के आधार पर छांटना चाहते हैं तो यह मददगार है।

list_of_tuples = [(1,2), (3,4), (5,0)]
list_of_tuples.sort(key=itemgetter(1))
print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]

यदि आप किसी ऑब्जेक्ट की विशेषताओं के आधार पर सॉर्ट करना चाहते हैं, तो attrgetter उपयोग करें

persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
           Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
           Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #reusing Person class from above example

person.sort(key=attrgetter('name')) #sort by name
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #sort by birthday

clear() - सूची से सभी आइटम निकालता है
```
a.clear()
# a = []
```
प्रतिकृति - किसी मौजूदा सूची को एक पूर्णांक से गुणा करने पर एक बड़ी सूची तैयार होगी जिसमें मूल की कई प्रतियां शामिल होंगी। यह सूची आरंभीकरण के लिए उदाहरण के लिए उपयोगी हो सकता है:
```
b = ["blah"] * 3
# b = ["blah", "blah", "blah"]
b = [1, 3, 5] * 5
# [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]
```
यह ध्यान रखें कि यदि आपकी सूची में वस्तुओं का संदर्भ है (उदाहरणों की सूची), तो सामान्य नुकसान - सूची गुणा और सामान्य संदर्भ देखें ।
तत्व विलोपन - del कीवर्ड और स्लाइस नोटेशन का उपयोग करके सूची में कई तत्वों को हटाना संभव है:
```
a = list(range(10))
del a[::2]
# a = [1, 3, 5, 7, 9]
del a[-1]
# a = [1, 3, 5, 7]
del a[:]
# a = []
```
प्रतिलिपि बनाई जा रही
डिफ़ॉल्ट असाइनमेंट "=" नए नाम के लिए मूल सूची का संदर्भ प्रदान करता है। यही है, मूल नाम और नया नाम दोनों समान सूची ऑब्जेक्ट की ओर इशारा करते हैं। उनमें से किसी के माध्यम से किए गए परिवर्तन दूसरे में परिलक्षित होंगे। यह अक्सर आप का इरादा नहीं है।
```
b = a
a.append(6)
# b: [1, 2, 3, 4, 5, 6]
```
यदि आप नीचे दी गई सूची की एक प्रति बनाना चाहते हैं।
आप इसे स्लाइस कर सकते हैं:
```
new_list = old_list[:]
```
आप अंतर्निहित सूची () फ़ंक्शन का उपयोग कर सकते हैं:
```
new_list = list(old_list)
```
आप जेनेरिक copy.copy () का उपयोग कर सकते हैं:
```
import copy
new_list = copy.copy(old_list) #inserts references to the objects found in the original.
```
यह सूची की तुलना में थोड़ा धीमा है (क्योंकि इसमें पुराने_सूची के डेटाटाइप को पहले पता लगाना है।
यदि सूची में ऑब्जेक्ट हैं और आप उन्हें भी कॉपी करना चाहते हैं, तो जेनेरिक copy.deepcopy () का उपयोग करें:
```
import copy
new_list = copy.deepcopy(old_list) #inserts copies of the objects found in the original.
```
स्पष्ट रूप से सबसे धीमी और सबसे स्मृति-आवश्यकता विधि, लेकिन कभी-कभी अपरिहार्य।

अजगर 3.x 3.0

copy() - सूची की उथली प्रति लौटाता है

    aa = a.copy()
    # aa = [1, 2, 3, 4, 5]

एक सूची की लंबाई

सूची की एक-आयामी लंबाई पाने के लिए len() का उपयोग करें।

len(['one', 'two'])  # returns 2

len(['one', [2, 3], 'four'])  # returns 3, not 4

len() सूचियों के समान स्ट्रिंग्स, शब्दकोशों और अन्य डेटा संरचनाओं पर भी काम करता है।

ध्यान दें कि len() एक अंतर्निहित फ़ंक्शन है, किसी सूची ऑब्जेक्ट का एक तरीका नहीं है।

यह भी ध्यान दें कि len() की लागत len() O(1) , जिसका अर्थ है कि किसी सूची की लंबाई को उसकी लंबाई की परवाह किए बिना प्राप्त करने में उतना ही समय लगेगा।

एक सूची में बदलाव

अजगर एक सूची में सीधे लूप के for उपयोग का समर्थन करता है:

my_list = ['foo', 'bar', 'baz']
for item in my_list:
    print(item)

# Output: foo
# Output: bar
# Output: baz

आप एक ही समय में प्रत्येक आइटम की स्थिति भी प्राप्त कर सकते हैं:

for (index, item) in enumerate(my_list):
    print('The item in position {} is: {}'.format(index, item))
 
# Output: The item in position 0 is: foo
# Output: The item in position 1 is: bar
# Output: The item in position 2 is: baz

सूचकांक मूल्य के आधार पर सूची को पुनरावृत्त करने का दूसरा तरीका:

for i in range(0,len(my_list)):
    print(my_list[i])
#output:
>>>
foo
bar
baz

ध्यान दें कि उस पर पुनरावृत्ति करते समय किसी सूची में आइटम बदलना अप्रत्याशित परिणाम हो सकता है:

for item in my_list:
    if item == 'foo':
        del my_list[0]
    print(item)

# Output: foo
# Output: baz

इस अंतिम उदाहरण में, हमने पहले पुनरावृत्ति में पहले आइटम को हटा दिया, लेकिन इसके कारण bar को छोड़ दिया गया।

यह जाँचना कि कोई वस्तु सूची में है या नहीं

पायथन यह जांचना बहुत आसान बनाता है कि कोई सूची में कोई वस्तु है या नहीं। बस ऑपरेटर in उपयोग करें।

lst = ['test', 'twest', 'tweast', 'treast']

'test' in lst
# Out: True

'toast' in lst
# Out: False

नोट: सेट पर ऑपरेटर in सूचियों की तुलना में विषम रूप से तेज है। यदि आपको संभावित बड़ी सूचियों पर कई बार इसका उपयोग करने की आवश्यकता है, तो आप अपनी list को एक set बदलना चाहते हैं, और set पर तत्वों की उपस्थिति का परीक्षण कर सकते हैं।

slst = set(lst)
'test' in slst
# Out: True

सूची तत्वों को उलट देना

आप reversed फ़ंक्शन का उपयोग कर सकते हैं जो उलट सूची में एक पुनरावृत्ति देता है:

In [3]: rev = reversed(numbers)

In [4]: rev
Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

ध्यान दें कि सूची "संख्या" इस ऑपरेशन से अपरिवर्तित बनी हुई है, और मूल रूप से उसी क्रम में बनी हुई है।

जगह में उल्टा करने के लिए, आप reverse विधि का उपयोग भी कर सकते हैं।

आप स्लाइसिंग सिंटैक्स का उपयोग करके एक सूची (वास्तव में एक प्रति प्राप्त करना, मूल सूची अप्रभावित है) को रिवर्स कर सकते हैं - तीसरे तर्क (चरण) को -1 के रूप में सेट करें:

In [1]: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [2]: numbers[::-1]
Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

यदि सूची खाली है तो जाँच की जा रही है

किसी सूची की शून्यता बूलियन False से जुड़ी होती है, इसलिए आपको len(lst) == 0 जांच करने की आवश्यकता नहीं है, लेकिन सिर्फ lst या not lst

lst = []
if not lst:
    print("list is empty")

# Output: list is empty

कॉनकैटनेट और मर्ज सूची

CONCATENATE सबसे आसान तरीका list1 और list2 :
```
merged = list1 + list2
```
zip tuples की एक सूची देता है , जहाँ i-th tuple में प्रत्येक तर्क क्रम या पुनरावृत्तियों से i-th तत्व समाहित है:
```
alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3']

for a, b in zip(alist, blist):
    print(a, b)
 
# Output:
# a1 b1
# a2 b2
# a3 b3
```
यदि सूचियों की लंबाई अलग-अलग है, तो परिणाम में कम से कम एक के रूप में कई तत्व शामिल होंगे:
```
alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3', 'b4']
for a, b in zip(alist, blist):
    print(a, b)

# Output:
# a1 b1
# a2 b2
# a3 b3

alist = []
len(list(zip(alist, blist)))

# Output:
# 0
```
असमान लंबाई की पैडिंग सूचियों के लिए सबसे लंबे समय तक None साथ itertools.zip_longest ( itertools.izip_longest पायथन 2 में) का उपयोग करें
```
alist = ['a1', 'a2', 'a3']
blist = ['b1']
clist = ['c1', 'c2', 'c3', 'c4']

for a,b,c in itertools.zip_longest(alist, blist, clist):
    print(a, b, c)

# Output: 
# a1 b1 c1
# a2 None c2
# a3 None c3
# None None c4
```

एक विशिष्ट सूचकांक मूल्यों में सम्मिलित करें:

 alist = [123, 'xyz', 'zara', 'abc']
 alist.insert(3, [2009])
 print("Final List :", alist)

आउटपुट:

 Final List : [123, 'xyz', 'zara', 2009, 'abc']

किसी भी और सभी

आप all() यह निर्धारित करने के लिए उपयोग कर सकते हैं कि क्या सभी मान सत्य के मूल्यांकन से संबंधित हैं

nums = [1, 1, 0, 1]
all(nums)
# False
chars = ['a', 'b', 'c', 'd']
all(chars)
# True

इसी तरह, any() यह निर्धारित करता है कि क्या एक या एक से अधिक मान सत्य के मूल्यांकन से संबंधित हैं

nums = [1, 1, 0, 1]
any(nums)
# True
vals = [None, None, None, False]
any(vals)
# False

हालांकि यह उदाहरण एक सूची का उपयोग करता है, लेकिन इन अंतर्निहित कार्यों को जनरेटर सहित किसी भी पुनरावृत्ति के साथ नोट करना महत्वपूर्ण है।

vals = [1, 2, 3, 4]
any(val > 12 for val in vals)
# False
any((val * 2) > 6 for val in vals)
# True

सूची में डुप्लिकेट मान निकालें

एक सूची में डुप्लिकेट मानों को हटाकर सूची को set परिवर्तित करके किया जा सकता है (जो कि अलग-अलग वस्तुओं का अनियंत्रित संग्रह है)। यदि एक list डेटा संरचना की आवश्यकता है, तो सेट को फ़ंक्शन list() का उपयोग करके वापस एक सूची में परिवर्तित किया जा सकता है:

names = ["aixk", "duke", "edik", "tofp", "duke"]
list(set(names))
# Out: ['duke', 'tofp', 'aixk', 'edik']

ध्यान दें कि एक सूची को एक सेट में परिवर्तित करके मूल ऑर्डर खो जाता है।

सूची के क्रम को संरक्षित करने के लिए व्यक्ति OrderedDict उपयोग कर OrderedDict

import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Out: ['aixk', 'duke', 'edik', 'tofp']

नेस्टेड सूची में मान एक्सेस करना

तीन आयामी सूची के साथ शुरू:

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]

सूची में आइटम एक्सेस करना:

print(alist[0][0][1])
#2
#Accesses second element in the first list in the first list

print(alist[1][1][2])
#10
#Accesses the third element in the second list in the second list

समर्थन संचालन करना:

alist[0][0].append(11)
print(alist[0][0][2])
#11
#Appends 11 to the end of the first list in the first list

सूची मुद्रित करने के लिए छोरों के लिए नेस्टेड का उपयोग करना:

for row in alist: #One way to loop through nested lists
    for col in row:
        print(col)
#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#[12, 13, 14]

ध्यान दें कि इस ऑपरेशन का उपयोग सूची बोध में किया जा सकता है या यहां तक कि एक जनरेटर के रूप में भी दक्षता पैदा करने के लिए किया जा सकता है, जैसे:

[col for row in alist for col in row]
#[[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]

बाहरी सूचियों की सभी वस्तुओं को स्वयं सूचियाँ नहीं देनी हैं:

alist[1].insert(2, 15)
#Inserts 15 into the third position in the second list

छोरों के लिए नेस्टेड का उपयोग करने का एक और तरीका। दूसरा तरीका बेहतर है लेकिन मुझे इस अवसर पर इसका उपयोग करने की आवश्यकता है:

for row in range(len(alist)): #A less Pythonic way to loop through lists
    for col in range(len(alist[row])):
       print(alist[row][col])

#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#15
#[12, 13, 14]

नेस्टेड सूची में स्लाइस का उपयोग करना:

print(alist[1][1:])
#[[8, 9, 10], 15, [12, 13, 14]]
#Slices still work

अंतिम सूची:

print(alist)
#[[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]

सूचियों की तुलना

तुलना संचालकों का उपयोग करके सूची और अन्य दृश्यों की तुलनात्मक रूप से करना संभव है। दोनों ऑपरेंड एक ही प्रकार के होने चाहिए।

[1, 10, 100] < [2, 10, 100]
# True, because 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, because the lists are equal
[1, 10, 100] <= [1, 10, 100]
# True, because the lists are equal
[1, 10, 100] < [1, 10, 101]
# True, because 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, because 0 < 1

यदि सूचियों में से एक दूसरे की शुरुआत में निहित है, तो सबसे छोटी सूची जीत जाती है।

[1, 10] < [1, 10, 100]
# True

तत्वों की एक निश्चित संख्या की सूची को आरम्भ करना

अपरिवर्तनीय तत्वों (उदाहरण के लिए None , स्ट्रिंग शाब्दिक आदि):

my_list = [None] * 10
my_list = ['test'] * 10

उत्परिवर्तित तत्वों के लिए, समान निर्माण में सूची के सभी तत्वों का परिणाम एक ही वस्तु के लिए होगा, उदाहरण के लिए, एक सेट के लिए:

>>> my_list=[{1}] * 10
>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]

इसके बजाय, विभिन्न उत्परिवर्तित वस्तुओं की निश्चित संख्या के साथ सूची को आरम्भ करने के लिए, उपयोग करें:

my_list=[{1} for _ in range(10)]

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

Python Language
सूची

खोज…