python list create
Bu Python Listesi eğitiminde, tartışmasız en kullanışlı veri türlerinden biri olan Python Listelerine Eleman Oluşturma, Erişme, Dilimleme, Ekleme / Silme yollarını keşfedeceğiz:
Python, aşağıda belirtildiği gibi 4 toplama veri türü içerir:
- Liste
- Ayarlamak
- Sözlük
- Tuple
Bu eğitimde List ve çeşitli işlemleri hakkında ayrıntılı olarak tartışacağız. Python'da liste bir veri yapısıdır veya aynı anda birden fazla veriyi depolamak için kullanılan bir dizi gibidir.
=> Python Eğitim Serisini Buradan Keşfedin
Java, C, C ++ vb. Gibi diğer programlama dillerinde deneyiminiz varsa, diziler kavramına aşina olacaksınız. Liste dizilerle hemen hemen aynıdır.
Ne öğreneceksin:
- Python Listeleri Nedir
- Python'daki Listeler Hakkında Daha Fazla Bilgi
- Sonuç
Python Listeleri Nedir
Python'da bir liste bir veri tipi , köşeli parantez (()) içinde farklı nesnelerin (öğeler) bir koleksiyonunu depolayan. Listedeki her öğe, ilk öğe 0 dizininde olacak şekilde virgülle (,) ayrılır.
Not :İleriye bakacak olursak, bu eğitimdeki tüm örnekler, aksi belirtilmedikçe, doğrudan bir Python kabuğundan çalıştırılacaktır.
Aşağıda 5 maddeli bir liste örneği bulunmaktadır.
>>> l = ('what','who','where','when','how') >>>l ('what','who','where','when','how')
Yukarıdaki örnekte, listenin sahip olduğunu görebiliriz. Dize nesneleri öğeler olarak ve her öğe virgülle ayrılmıştır.
Python Listesinin Özellikleri
Bir listedeki öğeleri nasıl değiştirebileceğimize bakmadan önce, Python listelerini tercih edilen özelliklerden bazılarına bakalım.
Python Listeleri Kapsayıcı Dizileridir
Düz dizilerin aksine ( dizi , dizi.array , bellek görünümü , vb.) yalnızca bir türdeki öğeleri tutabilen bir liste, konteyner dizisi Bu, bir türden olduğu kadar farklı türdeki öğeleri de tutabilir.
Tek tip öğelerle örnek
Python kabuğumuzu açalım ve bir sayı listesi tanımlayalım.
>>> numbers = ('one','two','three','four','five') >>> numbers ('one','two','three','four','five')
Yukarıdaki örnek, aynı türdeki öğelerin bir listesini gösterir, bu tür durumda dize (str) .
Farklı türdeki öğelerle örnek
Python kabuğumuzu açalım ve bir sayı listesinin başka bir sürümünü tanımlayalım.
>>> numbers = ('one',2,3,'four',5.0) >>> numbers ('one',2,3,'four',5.0)
Yukarıdaki örnek, farklı türlerdeki öğelerin bir listesini göstermektedir. Türler dizi , tamsayı ve yüzen .
// a sketch showing the list of items and their types as annotation
Python listesi aşağıdaki gibi tüm nesneleri de tutabilir: fonksiyonlar , sınıflar , modüller , listeler , tuples ve daha fazlası.
Bir düzenleyici açın ve aşağıdaki kodu yapıştırın:
def test(): '''This is a function''' print('This is a test') if __name__ == '__main__': print(test) # return instance object of function 'test' instance = type(test) print(instance) # create a list of colors colors = ('red','blue','green') print(colors) # create a list holding all the various data types defined above, including boolean. my_list = (test, instance, colors, False) print(my_list)
Çıktı
Python Listeleri Sıralı Dizilerdir
Bir Python listesi, nesnelerin sıralı bir koleksiyonudur. Listedeki her bir öğenin konumu çok önemlidir. Aslında, öğelerin yerleştirildiği sıra aynı değilse, aynı öğelere sahip iki liste aynı değildir.
>>> ('a','b','c','d') == ('a','c','b','d') False
Python listesinin bu özelliği, öğelerine dizin ve dilimleme yoluyla erişmeyi mümkün kılar. (bu konu hakkında daha sonra daha fazlası).
Python Listeleri Değişken Dizilerdir
Python listeleri değiştirilebilir. Ama değişebilir nesne nedir? Basitçe, oluşturulduktan sonra değiştirilebilen bir nesnedir. Örnekler diğer değişebilir dizilerin sözlük , dizi.array , collections.deque .
Neden değişken? Listeler gibi diziler karmaşık işlemler için kullanılır, bu nedenle bunları yapabilmeleri mantıklıdır. değişiklik , büyümek , küçültmek , güncelleme vb. . Bu sadece değişebilirlik ile mümkündür. Değişebilirlik ayrıca listeleri yerinde değiştirmemizi sağlar (bu konuda daha fazlası).
Aşağıdaki örnekle bir listenin değişkenliğini doğrulayalım.
Bir düzenleyici açın ve kodu yapıştırın:
def veryfiy_mutability(): # create a list l = (9,0,4,3,5) print('Display before modifying') print('List: {}
Id: {}'.format(l,id(l))) # modify the list by replacing the item at # index 3 to the item -2. l(3) = -2 print('Display after modifying') print('List: {}
Id: {}'.format(l,id(l))) if __name__ == '__main__': veryfiy_mutability()
Çıktı
Yukarıdaki çıktıdan, değişiklikten önceki ve sonraki listenin farklı olduğunu fark ettik. Ancak İD değer aynı. İD Buradaki değer nesnenin bellekteki adresini temsil eder - bu Python ile elde edilir İD() .
Bu bize, liste içeriği değişmiş olsa da, yine de aynı nesne olduğunu söyler. Dolayısıyla bu, tanımımızı karşılar: ' Bu basitçe, oluşturulduktan sonra değiştirilebilen bir nesnedir '
Not :Yukarıdaki örnekte, listeyi değiştirmek için indekslemeyi (bu konuda daha fazlası) kullandık.
Python Listelerini Düzenleme
Python listeleri ile gökyüzü bizim sınırımızdır. Gibi listelerle yapabileceğimiz sayısız şey var ekleme , siliniyor , indeksleme , dilimleme , üyelik kontrolü , ve daha fazlası. Ayrıca Python, listeleri manipüle etmeyi daha heyecanlı hale getirmeye yardımcı olan yerleşik işlevlere sahiptir.
Bu bölümde, yaygın olarak kullanılan bazı liste işlemlerine bakacağız.
Liste Oluşturmak
Bir liste oluşturmak için, köşeli parantez içine virgülle ayrılmış bir dizi öğe veya ifade koymanız yeterlidir.
(expression1, expression2,...,expresionN)
>>> l = (4,3,5,9+3,False) >>> l (4, 3, 5, 12, False)
Ayrıca, Python'un adında yerleşik bir nesnesi vardır. liste () listeleri oluşturmak için kullanılabilir.
list( sequence )
>>> l = list() # create an empty list >>> l ()
Python liste () sıra türlerini alabilir ve bunları listelere dönüştürebilir. Bu, bir demeti bir listeye dönüştürmenin tipik yoludur.
>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list (4,3,5)
Yukarıdaki örnekte, veri türünü kullandık Tuple . Bir listeye benzer, ancak listelerden farklı olarak, değişmezdir ve öğeleri parantez içine alınır.
Liste oluşturmanın başka bir yolu da liste anlayışları aşağıdaki sözdizimine sahiptir.
(expression for item in sequence)
>>> (i**2 for i in range(4)) (0, 1, 4, 9)
Python listelerinin referans olarak aktarıldığını belirtmekte fayda var. Yani, bir listenin atanması, onun bellek konumu kimliğini sağlayacaktır. Pek çok aceminin yaptığı hata, bu şekilde listeler oluşturmaktır.
>>> l1 = l2 = (4,3) # wrong way to create separate list objects >>> l1 (4,3) >>> l2 (4,3)
Burada iki farklı liste oluşturduğumuzu düşünebiliriz, ancak gerçekten yeni bir tane oluşturduk. Değişkenlerden birini değiştirerek bunu gösterelim.
>>> l1(0) = 0 >>> l1 (0,3) >>> l2 (0,3)
Bir değişkeni değiştirmenin diğerini değiştirdiğini fark ettik. Bunun nedeni, hem l1 hem de l2 değişkenlerinin aynı bellek konumu kimliğine sahip olmaları, dolayısıyla her ikisinin de aynı nesneyi göstermesidir.
Bir Listeye Öğe Ekleme
Python, listesine öğe eklemenin birçok yolu vardır. En yaygın yol, ekle () yöntem. Diğer yollar, uzat () yöntem. Endeksleme ve dilimleme (daha sonra bunlarla ilgili daha fazla bilgi) bir listedeki öğeleri değiştirmek için daha çok kullanılır.
# 1) append () yöntemini kullanma
Bu yöntem tek bir öğeyi alır ve onu listenin sonuna ekler. Yeni bir liste döndürmez, sadece listeyi yerinde değiştirir (değişebilirliği sayesinde).
>>>l = list() # create empty list >>> l () >>> l.append(4) # add an integer >>> l (4) >>> l.append((0,1)) # add a list >>> l (4, (0, 1)) >>> l.append(4 >> l (4, (0, 1), True) >>> l.append(x for x in range(3)) # add result of a tuple comprehension >>> l (4, (0, 1), True, )
Yukarıdaki örnekte not edilecek birkaç nokta:
- Buradaki öğeler ifadeler, veri türleri, sıralar ve daha fazlası olabilir.
- ekle () yöntemin zaman karmaşıklığı (0) 1'dir. Yani sabittir.
# 2) Extend () yöntemini kullanma
Bu yöntem, argüman olarak bir yinelenebilirliği alır ve ondan tüm öğeleri listenin sonuna ekler. Bu yöntem çoğunlukla bir dizinin tek tek öğelerini bir listeye eklemek istediğimizde kullanılır.
Temel olarak uzat () yöntem, bağımsız değişkenini yineler ve her öğeyi listeye ekler. Aynı append () yöntemi gibi, yeni bir liste döndürmez, ancak yerinde listeyi değiştirir.
>>> l1 = (3,2,5) # create a list of items >>> l1 (3, 2, 5) >>> l2 = (0,0,-1) # create a second list of items >>> l2 (0, 0, -1) >>> str = 'hello' # create a string(iterable) >>> str 'hello' >>> l1.extend(l2) # append all items from l2 to l1 >>> l1 (3, 2, 5, 0, 0, -1) >>> l1.extend(str) # append all items from str to l1 >>> l1 (3, 2, 5, 0, 0, -1, 'h', 'e', 'l', 'l', 'o')
Yukarıdaki örnekte not edilecek birkaç nokta:
- Bir dize yinelenebilir, dolayısıyla bizim uzat () yöntem, karakterleri üzerinde yinelenir.
- uzat () yöntemin zaman karmaşıklığı var (0) K, burada K, argümanının uzunluğudur.
Bir Listeden Öğelere Erişim
Endeksleme ve dilimleme listelere erişmek için kullanılan en yaygın yöntemlerdir. Ayrıca aşağıdaki gibi döngüler içeren bir listedeki öğelere de erişebiliriz döngü için .
# 1) Endeksleme
Bir Python listesi, sıfır tabanlı numaralandırma sistemi. Yani, tüm öğeleri 0'dan n-1'e başlayan bir dizin numarasıyla benzersiz bir şekilde tanımlanır; burada n, listenin uzunluğudur.
Aşağıdaki listeyi düşünün:
>>> colors = ('red','blue','green','yellow','black') # create list >>> colors ('red','blue','green','yellow','black') >>> len(colors) # get list length 5
Aşağıdaki tablo, ilgili endeksleri göstermektedir. bir listenin sıfır tabanlı numaralandırılması.
Öğe | ağ | mavi | yeşil | Sarı | siyah |
---|---|---|---|---|---|
pop () | Bir listenin sonundaki öğeyi silmek / kaldırmak için. | ||||
Dizin | 0 | 1 | iki | 3 | 4 |
Yukarıdaki tablodan, ilk öğenin ('kırmızı') 0 dizin konumunda ve son öğenin ('siyah'), n = 5'in (nesnenin uzunluğu) dizin konumunda 4 (n-1) olduğunu görüyoruz. renkler).
Yukarıdaki karakteristik bölümde gördüğümüz gibi, Python listeleri sıralı dizilerdir. Bu, öğeye kolayca erişmek ve üzerinde değişiklik yapmak için indekslemeyi kullanmamızı sağlar.
Yukarıda oluşturulan renkler nesnesinin belirli indekslerindeki öğelere erişmek için indekslemeyi kullanalım.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0) # access item at index 0 'red' >>> colors(4) # access item at index 4 'black' >>> colors(9) # access item at index 9 Traceback (most recent call last): File '', line 1, in IndexError: list index out of range
Not :Yukarıdaki son ifade, uzunluk 5 olan bir liste nesnesinden 9 dizin konumundaki bir öğeye erişmeye çalışıyor. Python listesinde, var olmayan bir dizindeki bir öğeye erişmek, IndexError istisna.
İndekslemenin önemli bir kavramı, negatif indekslemeyi kullanabilmemizdir, yani bir listenin öğelerine, son öğe için -1'den başlayarak ve n'nin liste nesnesinin uzunluğu olduğu son öğe için -n ile biten ters bir şekilde erişebiliriz.
Yukarıdaki tabloda, negatif indeksleme kullanırsak, aşağıdaki gibi görünecektir:
Öğe | ağ | mavi | yeşil | Sarı | siyah |
---|---|---|---|---|---|
Dizin | -5 | -4 | -3 | -iki | -1 |
Yukarıda oluşturulan renk nesnesinin bazı öğelerine erişmek için negatif indekslemeyi kullanalım.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-1) # access item and index -1(first item counting backward) 'black' >>> colors(-3) # access item at index -3(third item counting backward) 'green' >>> colors(-5) # access item at index -5 (last item counting backward) 'red'
# 2) Dilimleme
Yalnızca bir öğe döndüren indekslemenin aksine, dilimleme Öte yandan, bir dizi öğe döndürebilir.
Aşağıdaki sözdizimine sahiptir:
L(n:m)
N, dilimin başladığı dizin numarası olduğunda (varsayılan olarak 0'dır) ve m, dilimin bittiği özel dizin numarası olduğunda (varsayılan uzunluk-1'dir). İki nokta üst üste (:) ile ayrılırlar
Yukarıda oluşturulan renkler nesnesinin belirli indekslerindeki öğelere erişmek için dilimlemeyi kullanan aşağıdaki örneği düşünün.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:2) # get first two items ('red', 'blue') >>> colors(1:4) # get items at index 1,2 and 3 ('blue', 'green', 'yellow') >>> colors(2:len(colors) # get items from index 2 to the last item ('green', 'yellow', 'black') >>> colors(3:4) # get one item at index 3. Same as colors(3) ('yellow') >>>
Sözdiziminde L (n: m), n varsayılanı 0'dır ve m varsayılanı listenin uzunluğudur. Yani, içinde örnekler 1 ve 3 yukarıda, sırasıyla renkler (: 2) ve renkler (2:) olarak n ve m'yi çıkarabiliriz. Veya (:) bu durumda tüm liste nesnesinin basit bir kopyasını döndürür.
Listeleri dilimlerken negatif indeks sayıları da kullanabiliriz. Bu, genellikle listeye ters bir şekilde erişmek istediğimizde kullanılır.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-3:-2) ('green') >>> colors(-2:) ('yellow', 'black')
Ayrıca, dilimlemeyi destekleyen üçüncü bir parametre vardır. adım (s). Listeden ilk öğe alındıktan sonra kaç öğenin ileriye taşınacağını tanımlar. Varsayılan olarak 1'dir.
L(n:m:s)
Yukarıda tanımlanan aynı renk listemizi kullanarak, dilimin üçüncü parametresini 2 adım taşımak için kullanalım.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:3:2) ('red', 'green')
# 3) Döngüleri kullanma
Döngüler çoğunlukla, öğeleri işlemek için bir listedeki öğelere erişmek için kullanılır. Bu nedenle, bir listenin öğeleri üzerinde işlem yapmak istememiz durumunda, döngü için öğelere erişmek ve çalıştırılmak üzere iletmek için.
Diyelim ki, her öğe için harf sayısını saymak istiyoruz. Kullanabiliriz döngü için bunu başarmak için.
Bir düzenleyici açın ve aşağıdaki kodu yapıştırın:
def count_letters(l): count = {} # define a dict to hold our count for i in l: # loop through the list count(i) = len(i) # for each item, compute its length and store it in the dict return count # return the count if __name__ == '__main__': colors = ('red', 'blue', 'green', 'yellow', 'black') print(count_letters(colors))
Çıktı
Bu bölümü bitirmek için, dilimleme ile yapılabilecek iki harika şeye bakalım.
-
Bir listenin basit bir kopyasını alın
Kullanmanın temel yolu kopya () liste nesnesinin veya yerleşik işlevin yöntemi copy.copy . Ancak bu, dilimleyerek elde edilebilir.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors_copy = colors(:) # make a shallow copy >>> colors_copy ('red', 'blue', 'green', 'yellow', 'black') >>> colors_copy(0) = 0 # modify item at index 0 by changing its value to 0 >>> colors_copy # the copied version now has 0 at index 0 (0, 'blue', 'green', 'yellow', 'black') >>> colors # the original version is unchanged ('red', 'blue', 'green', 'yellow', 'black') >>>
-
Bir listeyi ters çevir
Temel yol, ters liste nesnesinin veya yerleşik işlevin yöntemi ters () . Ancak bu, dilimleyerek elde edilebilir.
>>> colors # original list object ('red', 'blue', 'green', 'yellow', 'black') >>> colors(::-1) # returns a reversed shallow copy of the the original list ('black', 'yellow', 'green', 'blue', 'red') >>>
Listeden Öğeleri Çıkarma
Bir listeye çok sayıda öğe ekleyebildiğimiz için, bunlar bir listeden de çıkarılabilir. Öğelerin kaldırılabileceği üç yol şunlardır:
# 1) del ifadesini kullanma
Aşağıdaki sözdizimine sahiptir:
del target_list
Hedef listesi ( target_list ) tüm liste (listeyi silmek istemeniz durumunda) veya listedeki bir öğe veya öğeler (bu durumda indeksleme veya dilimleme kullanırsınız) olabilir.
Aşağıdaki örneği düşünün .
Diyelim ki, yukarıda oluşturulan renkler listesinden bazı öğeleri silmek istiyoruz.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> del c_copy(0) # delete item at index 0 >>> c_copy ('blue', 'green', 'yellow', 'black') >>> del c_copy(0:2) # delete items at index 0 and 1(slicing) >>> c_copy ('yellow', 'black') >>> del c_copy(:) # delete all items in a list. Same as ‘c_copy.clear()’ () >>> del c_copy # delete the list object >>> c_copy # access object that doesn't exist Traceback (most recent call last): File '', line 1, in NameError: name 'c_copy' is not defined >>>
Not :Del ifadesi siler yerinde yani , yeni bir liste nesnesi döndürmek yerine orijinal liste nesnesini değiştirecektir.
# 2) list.remove (x) işlevini kullanma
Değeri eşit olan listeden ilk öğeyi kaldırır. x . Böyle bir öğe yoksa bir ValueError yükseltir.
Bu yöntem, dizinleme ve dilimlemeyi kullanan del ifadesinin aksine, çoğunlukla bir listeden öğeleri ada göre kaldırmak için kullanılır.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # create shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # remove first item with name 'blue' >>> c_copy ('red', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # try to remove item that doesn't exist Traceback (most recent call last): File '', line 1, in ValueError: list.remove(x): x not in list >>>
Not :Liste nesnesi Kaldır() yöntem siler yerinde yani , yeni bir liste nesnesi döndürmek yerine orijinal liste nesnesini değiştirecektir.
# 3) list.pop ((i)) kullanma
Bir liste nesnesinde verilen konumdaki öğeyi kaldırır ve döndürür. Hiçbir i (dizin) sağlanmazsa, listedeki son öğeyi kaldırır ve döndürür.
Not :İ'nin etrafındaki köşeli parantez i'nin listesi anlamına gelmez, i'nin isteğe bağlı olduğu anlamına gelir.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.pop(3) # pop out the item at index 3 'yellow' >>> c_copy ('red', 'blue', 'green', 'black') >>> c_copy.pop() # pop out the last item in the list 'black' >>> c_copy ('red', 'blue', 'green') >>>
Not: Liste. pop ((i)) yöntem siler yerinde yani , yeni bir liste nesnesi döndürmek yerine orijinal liste nesnesini değiştirecektir. Ayrıca, listeden kaldırılan öğeyi döndürür
Bir Listedeki Öğeleri Değiştirme
Öğeleri değiştirmek oldukça basittir. Yukarıdaki bölümlerden birinde indekslemeyi ve dilimlemeyi gördük. Bunlar, bir listeden öğelere erişmek ve bu öğeleri kaldırmak için kullanılabilir.
# 1) İndekslemeyi kullanarak değiştirin
L(index) = value
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy(0) = 'brown' # replace item at index 0 with 'brown' >>> c_copy ('brown', 'blue', 'green', 'yellow', 'black') >>>
# 2) Dilimleme kullanarak değiştirme
L(n:m) = value
Not : Değer bir olmalı tekrarlanabilir veya TypeError istisna gündeme getirilecek.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy(0:2) = ('brown') # replace items at index 0 and 1 with 'brown' >>> c_copy ('brown', 'green', 'yellow', 'black') >>> c_copy(1:3) = ('white','purple') # replace items at index 1 and 2 with 'white' and 'purple' >>> c_copy ('brown', 'white', 'purple', 'black') >>> c_copy(1:4) = ('white','purple') # replace items at index 1,2 and 3 with 'white' and 'purple'. Here we replace 3 items with 2 items >>> c_copy ('brown', 'white', 'purple') >>>
Sıkça Sorulan Sorular
S # 1) Python'daki listelerin listesi nedir?
Cevap: Python'daki listelerin bir listesi, liste öğesi olarak içeren bir listedir.
Örneğin
(('a','b'),('c','d'))
Aynı zamanda bir iç içe geçmiş liste .
S # 2) Python'da bir listeyi nasıl ilan edersiniz?
Cevap: Python'da bir liste iki şekilde bildirilebilir. Ya yerleşik işlevi kullanarak liste() veya köşeli parantez gösterimini () kullanarak. liste() yinelenebilir ve () virgülle ayrılmış her türden öğeyi alır.
(pytyon)>>> list('hello') # a string is iterable ('h', 'e', 'l', 'l', 'o') >>> (3,4,5,23) # numbers are separated by comma (3, 4, 5, 23) >>> (/python)
S # 3) Python listesine bir liste koyabilir misiniz?
Cevap: Evet, bir liste içine bir liste koyabiliriz. Aslında liste, herhangi bir veri türündeki öğeleri alan bir kap dizisidir.
S # 4) List () Python'da ne yapar?
Cevap: liste ( ) Python'da bir liste nesnesi oluşturan yerleşik bir işlevdir. Argüman olarak bir yinelenebilirliği alır.
>>> list((3,2,4)) # The iterable object here is a tuple. (3, 2, 4) >>>
S # 5) Bir Python listesi farklı türler içerebilir mi?
Cevap: Liste, herhangi bir veri türündeki öğeleri ( liste , tuple , tamsayı , yüzen , Teller , vb)
Python'daki Listeler Hakkında Daha Fazla Bilgi
Veri Yapısı nedir?
Bilgisayarlar, çok sayıda veriyi depolamak veya çok sayıda veriyi yüksek hız ve doğrulukla işlemek için kullanılır. Bu nedenle, hızlı erişim için verileri kalıcı olarak saklamak en iyisidir.
Veri işleme gerçekleşirken, mümkün olan en kısa sürede, doğruluk kaybı olmadan gerçekleşmelidir. Veri yapısını, verileri düzenli bir şekilde ele almak ve işlenmek üzere hafızada saklamak için kullanırız.
Python üst düzey ve yorumlanmış bir programlama dili olduğundan, Python'daki veri yapısından yararlanmak çok önemlidir.
Liste nedir?
Liste, birden çok veriyi aynı anda depolamak için kullanılan bir veri yapısıdır.
Bir listede depolanan veriler homojendir ve bu da onu Python'daki listenin en güçlü özelliği yapar. String, Tamsayılar ve nesneler gibi farklı veri türlerinin birden çok verisini tek bir listede saklayabiliriz.
Liste Python'da değiştirilebilir, bu nedenle veriler, oluşturulduktan sonra bile herhangi bir zamanda değiştirilebilir. Listeler, Python'da yığınları ve kuyrukları uygulamak için çok güçlüdür.
Daha önce tartışıldığı gibi, liste verileri sıralı bir sırada depolar ve bir listede saklanan verilere indeksleri kullanılarak erişilir ve liste için indeks her zaman Sıfırdan başlayacaktır. Listede her elemanın belirli bir yeri vardır ve tüm bu verilere bir indeks yardımıyla erişilir.
Listede, aynı değeri birden çok kez saklayabiliriz ve her veri ayrı ve benzersiz bir öğe olarak kabul edilecektir. Listeler, verileri depolamak ve daha sonra üzerinde yinelemek için en iyisidir.
Liste Oluşturmak
Listedeki veriler virgülle ayrılmış olarak ve köşeli parantez (()) içinde saklanır. Listedeki öğelerin aynı türde olması gerekmez.
Syntax: List = (item1, item2, item3)
Örnek 1:
List = ( )
Örnek 2:
List = (2, 5, 6.7)
Örnek 3:
List = (2, 5, 6.7, ‘Hi’)
Örnek 4:
List = (‘Hi’, ‘Python’, ‘Hello’)
Yukarıdaki örneklerde, farklı veri türlerinden öğeleri virgülle ayrılmış olarak depoladığımızı, 2 ve 5'in Tamsayı türünde, 6.7'nin float türünde ve 'Merhaba' String türünde olduğunu gözlemleyebiliriz, tüm bu öğeler bir liste ve bu onu bir Liste yapar.
Boş liste de ilan edebiliriz. Listeyi başka bir liste içinde de ilan edebiliriz ve buna iç içe liste diyoruz.
Örnek 5:
List = (‘Hi’, (2, 4, 5), (‘Hello’))
Yukarıdaki örnekte, bir listenin başka bir liste içerisinde ilan edildiğini gözlemleyebilirsiniz.
Listedeki Değerlere Erişim
Python'daki listede bulunan öğelere erişmenin çeşitli yolları vardır.
İndeks yardımı ile listenin elemanlarına ulaşabiliriz. Dizin 0'dan başlar ve dizin her zaman Tamsayı olmalıdır. Float gibi tamsayı dışında bir indeks kullanırsak, TypeError ile sonuçlanacaktır.
Örnek 1:
List = (2, 5, 6.7, ‘Hi’) print(“List is:”, List)
Çıktı:
Liste: (2, 5, 6.7, 'Merhaba')
Çıktı:
c ++ 'da normal ifade nasıl kullanılır
Yukarıdaki örnekte, listeyi doğrudan yazdırma işlevini kullanarak yazdırıyoruz, listeden tek tek öğeye erişmiyoruz.
Listeden tek tek öğeye erişelim.
Örnek: 2
List = (2, 5, 6.7, ‘Hi’) print(“Second element of the list is:”, List(1))
Çıktı:
Listenin ikinci unsuru: 5
Çıktı:
Yukarıdaki örnekte, listenin ikinci öğesi olan 5'i yazdırdığımızı görebilirsiniz, ancak print deyiminde List (1) 'i neden yazdırdığımıza dair bir soru alabilirsiniz. Bunun nedeni indeksin Sıfırdan başlamasıdır, dolayısıyla Liste (1) listenin ikinci elemanına atıfta bulunur.
Örnek: 3
List = (2, 5, 6.7, ‘Hi’) print(“First element in the List is: ”, List(0)) print(“Last element in the List is: ”, List(3))
Çıktı:
Listedeki ilk öğe: 2
Listedeki son öğe: Merhaba
Çıktı:
Örnek: 4
List = (‘Hi’, (2, 4, 5)) print(“First element of the list is: ”, List(0)(1)) print(“Elements present inside another list is: ”, List(1)(2))
Çıktı:
Listenin ilk öğesi: i
Başka bir listede bulunan öğeler: 5
Çıktı:
Yukarıdaki programda dikkatlice gözlemlerseniz iç içe listeden elementlere eriştiğimizi görebilirsiniz.
Dahili olarak, veriler aşağıda gösterildiği gibi bir matris formatında saklanacaktır:
Selam
2 4 5
Dolayısıyla Liste (0) (1) 'e erişmeye çalıştığımızda liste 1'i gösterecektir.stsatır ve 2ndsütun, dolayısıyla veriler 'i' olacaktır.
Benzer şekilde Liste (1) (2) 'ye erişmeye çalıştığımızda liste 2'yi gösterecektir.ndsıra ve 3rdsütun, dolayısıyla veriler 5 olacaktır.
Negatif Endeksleme
Verilere negatif indeks kullanarak da erişebiliriz. Negatif bir dizin her zaman -1'den başlar ve -1, son öğeyi belirtir ve -2, son ikinci öğeyi belirtir ve bu böyle devam eder.
Örnek 1
List = (2, 5, 7, 3) print(“Last element in the list is: ”, List(-1))
Çıktı:
Listedeki son eleman: 3
Çıktı:
Örnek: 2
List = (2, 5, 7, 3) print(“Second element in the list is: ”, List(-3))
Çıktı:
Listedeki ikinci unsur: 5
Çıktı:
Listeyi Dilimleme
Dilim operatörünü (:) kullanarak listeden bir dizi öğeye erişebiliriz
Örnek 1
List = (1, 2, 3, 4, 5, 6, 7) print(“Elements from 2nd to 5th is: ”, List(1:5)) print(“Elements beginning to 2rd is: ”, List(:-3)) print(“Elements 4th to end is: ”, List(3:)) print(“Elements from start to end is: “, List(:))
Çıktı:
2. ile 5. arasındaki öğeler: (2, 3, 4, 5)
2. ile başlayan öğeler: (1, 2, 3, 4)
4.'den sona kadar olan öğeler: (4, 5, 6, 7)
Baştan sona öğeler: (1, 2, 3, 4, 5, 6, 7)
Çıktı:
Listede bulunan öğelere for döngüsünü kullanarak da erişebiliriz.
Örnek: 2
List = (1, 2, 3, 4, 5, 6, 7) forele in List: print(ele)
Çıktı:
1
iki
3
4
5
6
7
Çıktı:
Aşağıdaki indeksleme formatını unutmayın:
H | DIR-DİR | L | L | VEYA | 5 | 7 | 9 | 4 |
0 | 1 | iki | 3 | 4 | 5 | 6 | 7 | 8 |
-9 | -8 | -7 | -6 | -5 | -4 | -3 | -iki | -1 |
Daha önce tartışıldığı gibi, List in python değiştirilebilir, yani öğeler bir Tamsayı veya Dize veya herhangi bir veri türü olsa bile değiştirilebilir.
Atama operatörünü kullanarak listeyi güncelleyebiliriz.
Örnek: 3
List = (2, 4, 6, 9) #updating the first element List(0) = 7 print(“Updated list is: ”, List)
Çıktı:
Güncellenen liste: (7, 4, 6, 9)
Çıktı:
Yukarıdaki örnekte, '2' listesinin ilk öğesini yeni bir '7' öğesiyle güncelliyoruz.
Örnek: 4
List = (2, 5, 1, 3, 6, 9, 7) #updating one or more elements of the list at once List(2:6) = (2, 4, 9, 0) print(“Updated List is: ”, List)
Çıktı:
Güncellenen Liste: (2, 5, 2, 4, 9, 0, 7)
Yukarıdaki örnekte, veri listesini listeye güncelliyoruz.
Çıktı:
Listeye Eleman Ekleme
Listeye eleman eklemenin birkaç yolu vardır ve python, append () adında yerleşik bir işleve sahiptir.
Append () kullanarak, listeye sadece bir eleman ekleyebiliriz, eğer listeye birden fazla eleman eklemek istiyorsanız, o zaman bizden yararlanmalıyız döngü için . append () işlevi her zaman öğeyi listenin sonuna ekler, append () işlevi yalnızca bir argüman alır.
Belirli bir konuma eleman eklemek istiyorsanız, sadece insert () yöntemini kullanmanız gerekir. insert () iki argüman alır, yani konum ve değer, konum, elemanların eklenmesi gereken dizini, değer ise listeye eklenecek öğeyi ifade eder.
Listeye eleman ekleyebileceğimiz, ext () adında bir yöntem daha var. Extend () yöntemi, listeye bir eleman listesi eklemek için kullanılır. Append () yöntemi ve Extend () yöntemine benzer şekilde, listenin sonuna öğeler de ekleyecektir.
Örnek 1
List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List)
Çıktı:
Değer eklemeden önceki liste: ('Merhaba', 'Günaydın')
Değerleri ekledikten sonraki liste: ('Merhaba', 'Günaydın', 'Python', 'Merhaba')
Yukarıdaki örnekte, Listenin sonuna 'Python' ve 'Hi' değerlerini ekliyoruz.
Çıktı:
Örnek: 2
List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) print(“Length of the list before appending is: “, len(List)) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List) print(“Length of the list after appending is: “, len(List))
Çıktı:
Değer eklemeden önceki liste: ('Merhaba', 'Günaydın')
Eklemeden önce listenin uzunluğu: 2
Değerleri ekledikten sonraki liste: ('Merhaba', 'Günaydın', 'Python', 'Merhaba')
Ekledikten sonra listenin uzunluğu: 4
Yukarıdaki örnekte gösterildiği gibi, len () işlevini kullanarak listenin uzunluğunu bulabiliriz.
Çıktı:
Ayrıca for döngüsünü kullanarak listeye birden çok değer ekleyebiliriz.
Örnek: 3
List = (7, 9, 8) print(“List before adding elements is: “, List) print(“Length of List before adding elements is: “, len(List)) for i in range(2, 6): List.append(i) print(“List after adding elements is: “, List) print(“Length of List after adding elements is: “, len(List))
Çıktı:
Öğe eklemeden önce liste: (7, 9, 8)
Öğe eklemeden önce Listenin uzunluğu: 3
Öğe ekledikten sonraki liste: (7, 9, 8, 2, 3, 4, 5)
Öğe ekledikten sonra Liste uzunluğu: 7
Çıktı:
Listenin bir listesini bir listeye eklersek ne olur? Bunu aşağıdaki örnekte görelim.
Örnek: 4
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.append(List2) print(“List1 after appending List2 is: “, List1)
Çıktı:
List2'yi ekledikten sonra Liste1: ('Merhaba', 'Python', (1, 5, 7, 2))
Yukarıdaki örnekte dikkat ederseniz, Liste2'yi Liste1'e eklediğimizde Liste1 iç içe bir liste haline gelecektir.
Çıktı:
Listeyi ekledikten sonra listeyi iç içe geçmiş bir liste yapmak istemiyorsanız, ext () yöntemini kullanmak daha iyidir.
Örnek: 5
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.extend(List2) print(“List1 after appending List2 is: “, List1)
Çıktı:
List2'yi ekledikten sonra Liste1: ('Merhaba', 'Python', 1, 5, 7, 2)
Extend () yöntemini kullandığımızda, List1'in elemanları List2'nin elemanları ile genişletilecektir. Extend () yöntemini kullandığımızda listeyi eklemeyeceğini unutmayın.
Çıktı:
Listeyi bir dizeyle genişlettiğinizde, dizge yinelenebilir olduğu için dizenin her karakterini listeye ekler.
Örnek: 6
List = (1, 5, 7, 2) List.extend(“Python”) print(“List after extending the String is: “, List)
Çıktı:
Dizeyi genişlettikten sonraki liste: (1, 5, 7, 2, 'P', 'y', 't', 'h', 'o', 'n')
Çıktı:
Liste ekleme () ve genişletme ()
Extend () ve append () için bazı örneklere göz atalım.
Örnek 1
def my_fun(): List1 = (“Hi”, 1, “Hello”, 2, 5) print(“The elements of List is: “, List) List.append(“Python”) print(“List after appending the String is: “, List) List.append((“one”, “two”, 3)) print(“List after appending the list is: “, List) List2 = (“Apple”, “Orange”, 2, 8) List1.extend(List2) print(“List1 after extending the List2 is: “, List1) if __name__ == “__main__”: my_fun()
Çıktı:
Listenin öğeleri: ('Merhaba', 1, 'Merhaba', 2, 5)
Dize eklendikten sonraki liste: ('Merhaba', 1, 'Merhaba', 2, 5, 'Python')
Listeyi ekledikten sonraki liste: ('Merhaba', 1, 'Merhaba', 2, 5, 'Python', ('bir', 'iki', 3))
List2'yi genişlettikten sonra Liste1: ('Merhaba', 1, 'Merhaba', 2, 5, 'Python', ('bir', 'iki', 3), 'Elma', 'Turuncu', 2, 8)
Çıktı:
Örnek: 2
List = (“Apple”, “Orange”, “Mango”, “Strawberry”) print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)
Çıktı:
Eklemeden önceki liste: ('Elma', 'Portakal', 'Mango', 'Çilek')
Ekledikten sonraki liste: ('Elma', 'Portakal', 'Karpuz', 'Mango', 'Çilek')
Çıktı
Daha önce tartıştığımız gibi, listenin belirli bir dizinine değer eklemek için insert () yöntemi kullanılır.
Örnek: 3
List1 = (2, 4, 6, 8) print(“List after adding the elements is: “, List1 + (1, 3, 5, 7)) print(“After adding same elements repeatedly is: “, (“Hi”) *5)
Çıktı:
Öğeleri ekledikten sonraki liste: (2, 4, 6, 8, 1, 3, 5, 7)
Aynı öğeleri tekrar tekrar ekledikten sonra: ('Merhaba', 'Merhaba', 'Merhaba', 'Merhaba', 'Merhaba')
Çıktı:
Bir Listeden Öğeleri Silme veya Kaldırma
Ayrıca del ve remove () ifadelerini kullanarak listedeki öğeleri silebilir veya kaldırabiliriz.
şirketinizin iç ağında güvenliği artırmak için
Aşağıdaki örnekte görelim.
Örnek 1
List = (1, 2, 3, 4, 5, 6, 7, 8, 9) print(“List before deleting 3rd element is: ”, List) del List(3) print(“List after deleting 3rd element is: ”, List) del List(1:3) print(“List after deleting multiple elements is: “, List)
Çıktı:
3. öğeyi silmeden önceki liste: (1, 2, 3, 4, 5, 6, 7, 8, 9)
3. öğeyi sildikten sonraki liste: (1, 2, 3, 5, 6, 7, 8, 9)
Birden çok öğeyi sildikten sonraki liste: (1, 5, 6, 7, 8, 9)
Yukarıdaki örnekte, listeden bir öğeyi veya birden çok ifadeyi silmek için del ifadesini kullandığımızı gözlemleyebilirsiniz.
Çıktı:
Şimdi remove () yöntemini göreceğiz.
Örnek: 2
List = (1, 2, 3, 4, 5, 6, 7) print(“List before removing a element is: “, List) List.remove(3) print(“List after removing a element is: “, List) List.pop() print(“List after poping the element is: “, List)
Çıktı:
Bir öğeyi kaldırmadan önce liste: (1, 2, 3, 4, 5, 6, 7)
Bir öğeyi kaldırdıktan sonraki liste: (1, 2, 4, 5, 6, 7)
Öğeyi açtıktan sonraki liste: (1, 2, 4, 5, 6)
Yukarıdaki örnekte, remove () yöntemini kullanarak bir öğeyi listeden kaldırdığımızı gözlemleyebilirsiniz. Pop () yöntemi, listeden son öğeyi kaldırmak / silmek için kullanılır.
Çıktı:
Liste Yöntemleri
Yöntemler | Açıklama |
---|---|
açık() | Listedeki tüm öğeleri kaldırmak için. |
ekle () | Listenin sonuna eleman eklemek için. |
ekle () | Listenin belirli bir dizinine öğe eklemek için. |
uzat () | Listenin sonuna eleman listesi eklemek için. |
Miktar() | Belirli bir değere sahip eleman sayısını döndürmek için. |
dizin () | İlk elemanın dizinini döndürmek için. |
ters() | Mevcut bir listeyi tersine çevirmek için. |
Kaldır() | Elemanları listeden çıkarmak için. |
Sonuç
Bu eğiticide, bazılarına baktık Python Listelerinin özellikleri gibi bir listeyi değiştirmenin çeşitli yolları ile birlikte bir liste oluşturmak , bir listeden öğelere erişim , ve bir listedeki öğeleri değiştirme.
Python listesindeki bu öğretici aşağıdaki İşaretçilerle sonuçlandırılabilir:
- Liste, veri yapısı olarak da adlandırılan Python'daki veri türlerinden biridir.
- Liste, herhangi bir veri türünün çok sayıda değerini tek bir değişkende saklamak için kullanılır ve bu da kolayca erişime yardımcı olur.
- Liste indeksi, diğer programlama dilleri gibi her zaman sıfırdan başlar.
- Liste üzerinde çalışıyorsanız, listenin tüm ortak yerleşik işlevlerini hatırlamanız gerekir.
=> Python'u Sıfırdan Öğrenmek İçin Burayı Ziyaret Edin
Önerilen Kaynaklar
- Yeni Başlayanlar İçin Python Eğitimi (Uygulamalı ÜCRETSİZ Python Eğitimi)
- Python Değişkenleri
- Python Gelişmiş Liste Eğitimi (Liste Sırala, Ters Çevir, Dizin, Kopyala, Birleştir, Topla)
- Uygulamalı Örneklerle Python Tuple Eğitimi
- Python Dizesi İşlevleri
- STL Listeleri
- Resimli C ++ 'da Bağlantılı Liste Veri Yapısı
- Çizim ile C ++ 'da Dairesel Bağlantılı Liste Veri Yapısı