Lists - Learn Python 3 - Snakify

Lesson 7
Listeler


1. Listeler

Programların çoğu sadece değişkenlerle çalışır. Ayrıca değişkenlerin listesini kullanırlar. Örneğin, bir program, bir sınıftaki öğrencilerle ilgili bilgileri, klavyeden veya bir dosyadan öğrencilerin listesini okuyarak işleyebilir. Sınıftaki öğrencilerin sayısındaki bir değişiklik, program kaynak kodunun değiştirilmesini gerektirmemelidir.

Önceden, bir dizinin elemanlarını işleme görevini zaten görmüştük - örneğin, dizinin en büyük öğesini hesaplarken. Ama tüm diziyi bilgisayar belleğinde tutmuyoruz. Bununla birlikte, bir çok problemde, dizinin tüm elemanlarını artan sırada ("bir sıralamayı sırala") yazdırmak zorunda olsaydık, tüm diziyi tutmak gerekir.

Bu verileri depolamak için, Python'da listelenen veri yapısını kullanabilirsiniz (çoğu programlama dilinde farklı terim kullanılır - “dizi”). Liste, dizideki karakterler gibi, 0 olarak numaralandırılmış öğeler dizisidir. Liste, öğeleri aşağıdaki gibi köşeli parantez içindeki öğeleri numaralandırarak manuel olarak ayarlanabilir:

Primes = [2, 3, 5, 7, 11, 13]
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']

Primes listenin 6 unsuru vardır: Primes[0] == 2 , Primes[1] == 3 , Primes[2] == 5 , Primes[3] == 7 , Primes[4] == 11 , Primes[5] == 13 . Rainbow listesi, her biri dize olan 7 öğeye sahiptir.

Dize içindeki karakterler gibi liste öğeleri de negatif indekse sahip olabilir, örneğin, Primes[-1] == 13 , Primes[-6] == 2 . Negatif indeks, son elemandan başladığımız ve bir liste okunurken sola dönüş yaptığımız anlamına gelir.

Listedeki elemanların sayısını len ( listenin uzunluğu anlamında), örn. len(Primes) == 6 .

Dizelerden farklı olarak, bir listenin öğeleri değiştirilebilir; yeni değerler atayarak değiştirilebilirler.

Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']
print(Rainbow[0])
Rainbow[0] = 'red'
print('Print the rainbow')
for i in range(len(Rainbow)):
    print(Rainbow[i])

Listeleri oluşturma ve okuma için çeşitli yollar düşünün. Öncelikle boş bir liste oluşturabilir (liste içermeyen liste, uzunluğu 0'dır) ve listeyi append listenin append . Örneğin, programın n listesindeki eleman sayısını aldığını ve ardından listenin n öğelerinin her birini ayrı bir satırda birer birer aldığını varsayalım. İşte bu formattaki giriş verilerinin bir örneği:

5
1809
1854
1860
1891
1925
Bu durumda, bu gibi bir listeden okumayı aşağıdaki gibi düzenleyebilirsiniz:
a = [] # boş bir liste başlat
n = int(input()) # listedeki elemanların sayısını oku
for i in range(n): 
    new_element = int(input()) # sonraki öğeyi oku
    a.append(new_element) # listeye ekle
    # Son iki satır bir tane ile değiştirilebilir:
    # a.append (int (giriş ()))
print(a)

Gösterilen örnekte boş liste oluşturulur, ardından elemanların sayısı okunur, sonra liste satırlarını satır satır okuyup sonuna eklersiniz. Aynı şey, n değişkeni kaydederek de yapılabilir:

a = []
for i in range(int(input())):
    a.append(int(input()))
print(a)

Listeler için tanımlanmış birkaç işlem vardır: liste birleştirme (listelerin eklenmesi, diğer bir deyişle bir listenin diğerine yapıştırılması) ve tekrar (bir listenin bir sayıyla çarpılması). Örneğin:

a = [1, 2, 3]
b = [4, 5]
c = a + b
d = b * 3
print([7, 8] + [9])
print([0, 1] * 3)

Sonuç listesi c , [1, 2, 3, 4, 5] d eşit olacak ve d nin bir listesi [4, 5, 4, 5, 4, 5] eşit olacaktır. Bu farklı okuma listeleri sürecini düzenlemek sağlar: ilk listenin boyutunu dikkate ve elemanların arzu edilen sayıda bir liste oluşturmak, değişken üzerinden sonra döngü i numarası 0 ile ve döngü içinde başlangıç okuma i -inci elemanı listenin

a = [0] * int(input())
for i in range(len(a)):
    a[i] = int(input())

Bir listenin elemanlarını a ile print(a) ; Bu, köşeli ayraçlarla çevrili ve virgülle ayrılmış liste öğelerini görüntüler. Genel olarak, bu rahatsız edici; Ortak olarak, tüm öğeleri bir satırda veya satır başına bir öğe olarak yazdırmak üzeresiniz. İşte bunun iki örneği, diğer döngü biçimlerini kullanarak:

a = [1, 2, 3, 4, 5]
for i in range(len(a)):
    print(a[i])

Burada i indeksi değiştirilir, daha sonra a[i] öğesi görüntülenir.

a = [1, 2, 3, 4, 5]
for elem in a:
    print(elem, end=' ')

Bu örnekte, liste öğeleri boşluklarla ayrılmış bir satırda görüntülenir ve değiştirilen dizin değil, değişkenin kendisinin değeridir (örneğin, for elem in ['red', 'green', 'blue'] için döngüde) for elem in ['red', 'green', 'blue'] değişken elem ardı ardına 'red' , 'green' , 'blue' değerleri alacaktır.

Son örneğe özellikle dikkat edin! Python ideolojisinin çok önemli bir parçasıdır for bazı dizisinin tüm unsurları üzerinde yineleme yapmak kolay bir yol sağlar döngü. Python'un Pascal'dan ayrıldığı yer burasıdır, burada elementlerin indeksleri üzerinde yinelemek zorundasınız, fakat elementlerin kendileri üzerinde değil.

Python'daki diziler, dizeler, listeler, işlev range() değerleri range() (bunlar listeler değildir) ve diğer bazı nesnelerdir.

Burada, bir dizeden tüm rakamları ayıklamak ve sayısal bir liste oluşturmak için gerektiğinde for döngüsünün kullanımını gösteren bir örnek verilmiştir.

# verilen: s = 'ab12c59p7dq'
# listeden rakamları çıkarmanız gerekiyor
# bunu yapmak için:
# rakam == [1, 2, 5, 9, 7]
s = 'ab12c59p7dq'
digits = []
for symbol in s:
    if '1234567890'.find(symbol) != -1:
        digits.append(int(symbol))
print(digits)
Advertising by Google, may be based on your interests

2. Böl ve birleştirme yöntemleri

Liste öğeleri bir karakterle ayrılmış bir satırda verilebilir; bu durumda, tüm liste input() kullanılarak okunabilir. Daha sonra, ilk dizeyi boşluklarla kesdikten sonra oluşan dizelerin listesini döndüren bir string yöntemi split() kullanabilirsiniz. Örnek:

# giriş bir dizedir
# 1 2 3
s = input() # s == '1 2 3'
a = s.split() # a == ['1', '2', '3']
print(a)

Bu programı 1 2 3 giriş verileriyle çalıştırırsanız, liste a ['1', '2', '3'] eşit olacaktır. Liste, sayılardan değil, dizelerden oluşacaktır. Sayıların listesini almak isterseniz, liste öğelerini tek tek tamsayıya dönüştürmeniz gerekir:

a = input().split()
for i in range(len(a)):
    a[i] = int(a[i])
print(a)

Python - jeneratörler özel büyüsünü kullanarak - aynı tek bir satırda yapılabilir:

a = [int(s) for s in input().split()]
print(a)

(Bir sonraki bölümde bu kod çalışır nasıl açıklayacağız.) Gerçek numaralarının bir listesini okumak isterseniz, tip değiştirmek zorunda int için float .

Method split() , liste öğeleri arasında ayraç olarak hangi dizenin kullanılacağını belirleyen isteğe bağlı bir parametreye sahiptir. Örneğin, yöntemi split('.') Çağırmak, ilk dizeyi '.' Karakterinin bulunduğu split('.') ayırarak elde edilen listeyi döndürür '.' karşılaşıldı:

a = '192.168.0.1'.split('.')
print(a)

Python'da, tek satırlı komutları kullanarak dizelerin bir listesini görüntüleyebilirsiniz. Bunun için, yöntem join kullanılır; Bu yöntemin bir parametresi vardır: dizelerin bir listesi. Verilen elemanların birleştirilmesiyle elde edilen dizgeyi döndürür ve ayırıcı listenin öğeleri arasına sokulur; Bu ayırıcı, uygulanan yöntem olan dizgeye eşittir. Bir önceki cümleyi ilk defa anlamadığınızı biliyoruz. :) Örneklere bak:

a = ['red', 'green', 'blue']
print(' '.join(a))
# kırmızı yeşil mavi dönüş
print(''.join(a))
# redgreenblue dönüş
print('***'.join(a))
# kırmızı verir *** yeşil *** mavi

Liste bir sayıdan oluşuyorsa, jeneratörlerin karanlık büyüsünü kullanmalısınız. Bir listenin elemanlarını boşluklarla ayrılmış olarak nasıl yazdırabilirsiniz:

a = [1, 2, 3]
print(' '.join([str(i) for i in a]))
# sonraki satır, bir tür hataya neden olur
# join () olarak yalnızca strs birleştirebilir
# yazdır ('' .join (a))

Ancak, karanlık büyü hayranı değilseniz, döngü for aynı etkiyi elde edebilirsiniz.

Advertising by Google, may be based on your interests

3. Jeneratörler

Aynı öğelerle dolu bir liste oluşturmak için listenin tekrarını kullanabilirsiniz, örneğin:

n = 5
a = [0] * n
print(a)

Daha karmaşık listeler oluşturmak için jeneratörler kullanabilirsiniz: bir listeye göre bir listeyi doldurmaya izin veren ifadeler. Bir jeneratörün genel şekli şöyledir:

[expression for variable in sequence]

variable bazı değişkenin kimliği olduğu durumda, sequence değişkeni alan bir değer dizisidir (bu, bir fonksiyon, bir dizi veya fonksiyon range kullanarak elde edilen bir nesne olabilir), expression - genellikle değişkendeki değişime bağlı olarak - Jeneratörde kullanılır. Liste elemanları bu ifadeye göre doldurulacak.

İşte jeneratörler kullanan bazı örnekler.

Jeneratörünü kullanarak n sıfırların bir listesini oluşturursunuz:

a = [0 for i in range(5)]
print(a)

Tamsayıların kareleriyle dolu bir liste nasıl oluşturursunuz:

n = 5
a = [i ** 2 for i in range(n)]
print(a)

1'den n kadar sayıların kareler listesini doldurmanız gerekiyorsa, range ayarlarını range(1, n + 1) :

n = 5
a = [i ** 2 for i in range(1, n + 1)]
print(a)

Burada (kullanarak 1'den 9'a kadar rastgele numaraları ile dolu bir listesini almak için ne yapmanız randrange modülünden random ):

from random import randrange
n = 10
a = [randrange(1, 10) for i in range(n)]
print(a)

Ve bu örnekte liste, standart girişten okunan satırlardan oluşacaktır: ilk olarak, listenin elemanlarının sayısını (bu değer fonksiyon range argümanı olarak kullanılacaktır), ikinci olarak - dizge sayısını girmeniz gerekir:

a = [input() for i in range(int(input()))]
print(a)
Advertising by Google, may be based on your interests

4. dilimler

Listeler ve dizelerle dilimler yapabilirsiniz. Yani:

A[i:j] dilim ji elemanları A[i] , A[i+1] , ..., A[j-1] .

A[i:j:-1] dilim ij elemanları A[i] , A[i-1] , ..., A[j+1] (yani, öğelerin sırasını değiştirerek).

A[i:j:k] aşaması ile kesilmiş k : A[i] , A[i+k] , A[i+2*k] , .... Eğer k <0 değeri ise, elemanlar karşıt sırayla gelir.

i ya da j numaralarının her biri eksik olabilir, “satırın başlangıcı” ya da “satırın sonu” anlamına gelir.

Listeler, dizelerden farklı olarak, değiştirilebilen nesnelerdir : bir liste öğesini yeni bir değere atayabilirsiniz. Ayrıca, tüm dilimleri değiştirmek mümkündür. Örneğin:

A = [1, 2, 3, 4, 5]
A[2:4] = [7, 8, 9]
print(A)

Burada bir liste [1, 2, 3, 4, 5] aldık ve daha sonra üç elemanın yeni bir listesi ile A[2:4] diliminin iki elemanını A[2:4] değiştirmeyi deneyelim. Elde edilen liste şöyledir: [1, 2, 7, 8, 9, 5] .

A = [1, 2, 3, 4, 5, 6, 7]
A[::-2] = [10, 20, 30, 40]
print(A)

Ve burada, sonuç listesi [40, 2, 30, 4, 20, 6, 10] . Nedeni, A[::-2] A[-1] , A[-3] , A[-5] , A[-7] elementlerinin bir listesidir ve bu elemanlar 10, 20, Sırasıyla 30, 40.

Süreksiz bir dilim (yani k adımı k olan bir dilim, k > 1 ) yeni bir değer atandığında, eski ve yeni dilimlerdeki öğelerin sayısı zorunlu olarak çakışır, aksi halde ValueError hatası oluşur.

A[i] bir dilim değil, bir liste öğesi olduğunu unutmayın!

Advertising by Google, may be based on your interests

5. Listelerdeki işlemler

Listelerle birçok farklı işlemi kolayca yapabilirsiniz.

A içinde x
Listedeki bir öğeyi kontrol edin. Doğru veya Yanlış döndürür
x A değil
Aynı değil (A'da x)
mina)
Listenin en küçük öğesi
v max (A)
Listedeki en büyük öğe
A.index (x)
Listedeki ilk eleman x'in indeksi; yokluğunda bir istisna ValueError oluşturur
A.count (x)
Listedeki x öğesinin gerçekleştiği olay sayısı
Advertising by Google, may be based on your interests
Advertising by Google, may be based on your interests