İçeriğe geç →

List & Tuple Mini Test (Python)

listve tuple bilginizi test etmek ister misiniz? realpython.com da keşfettiğim ve Türkçe’ye çevirdiğim mini teste bir göz atmak isteyebilirsiniz o zaman. Sorular temel ve orta seviyeden oluşmakta. Testin orijinaline buradan ulaşabilirsiniz.

Python listeleri için hangileri doğrudur?

  1. Tüm elemanlar aynı tipte olmalıdır.
  2. (Yüzeysel olarak) listelerin boyutu konusunda bir sınır yoktur.
  3. Bir liste, başka bir liste hariç herhangi bir tipte nesne içerebilir.
  4. Aşağıdaki listeler aynıdır:
    • ['a', 'b', 'c']
    • ['c', 'a', 'b']
  5. Bir nesne birden fazla kez listede bulunabilir.
Cevap
Doğru ifadeler 2 ve 5.

Liste, sıralı bir nesne koleksiyonudur. Elemanların sırası, listenin oluşturulduğu an belirlenir.

Bir liste, herhangi sayıda, herhangi tipte eleman içerebilir (bilgisayardaki ram durumuna bağlı olarak elbette). Aynı nesne birden fazla kez listede bulunabilir.

Çıktılardan hangileri doğrudur?

a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge'] şeklinde listemiz var.
>>> print(a[4::-2])
['quux', 'baz', 'foo']

>>> a[:] is a
True

>>> print(a[-5:-3])
['bar', 'baz']

>>> max(a[2:4] + ['grault'])
'qux'

>>> print(a[-6])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
Cevap
Python’da listelerin indeksi 0’dan başlar. Fakat listeyi tersine sıralamak isterseniz, son elemanın indeksi -1’dir. Yani:

['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

foo‘nun indeksi 0 ve -6’dır.
bar‘ın indeksi 1 ve -5’tir.
corge‘un indeksi 5 ve -1’dir.

Bu bilgileri göz önünde bulundurarak tekrar düşünürsek;

print(a[4::-2])

[4::-2] “slice syntax” (dilimleme yazımı), indeksi 4 olan elemandan (quux) başlar ve bir eleman atlayarak listenin başına doğru ilerler. Dolayısıyla indeksi 4, 2 ve 0 olan elemanları verecektir: ['quux', 'baz', 'foo']

print(a[-5:-3])

[-5:-3], -5. indeksten başlayıp -3. indekse kadar gider fakat -3. indeksi dahil etmez. Bu da “bar” ve “baz” elemanlarına denk gelir.

max(a[2:4] + ['grault'])

a[2:4], ['baz', 'qux'] döndürür. “+” operatörü birleştirme yapacağından, max() fonksiyonu için verilen argüman ['baz', 'qux', 'grault'] olacaktır. Stringler için maksimum değer alfabetik olarak bakılacağı için “qux” döndürülür.

print(a[-6]) hata fırlatmayacak çünkü negatif indeksler -1’den başladığı için, -6. indeks aslında listenin ilk elemanına (“foo”) denk gelmektedir.

Öte yandan, pozitif indeksler 0’dan başladığı için, 6. indeks geçerli bir indeks değildir.

a[:] is a

Eğer yukarıdaki kod string bir değer için olsaydı, “True” değeri dönerdi çünkü string için, s[:] s‘e ait referans döndürür.

Liste için, a[:] listenin bir kopyasını döndürür. Aynı nesneyi referans etmezler.

x = [10, [3.141, 20, [30, ‘baz’, 2.718]], ‘foo’]

"baz" içindeki "z"‘yi döndüren ifade nedir?

Cevap

x[1][2][1][2]

x[1], x içindeki ikinci elemanı döndürür: [3.141, 20, [30, 'baz', 2.718]]
x[1][2], alt listedeki üçüncü elemanı döndürür: [30, 'baz', 2.718]
x[1][2][1], bu alt listedeki ikinci elemanı döndürür: "baz"
x[1][2][1][2], “baz” içindeki üçüncü karakteri döndürür: "z"

Not: Negatif indeksleri de kullanarak aynı sonucu veren ifadeyi yazabiliriz elbette.

x = [10, [3.141, 20, [30, ‘baz’, 2.718]], ‘foo’]

Bu sefer de ['baz', 2.718] listesini döndüren ifade nedir?

Cevap

x[1], x içindeki ikinci elemanı döndürür: [3.141, 20, [30, 'baz', 2.718]]
x[1][2], alt listedeki üçüncü elemanı döndürür: [30, 'baz', 2.718]
x[1][2][1:3] ya da x[1][2][1:], listeyi şöyle dilimler: ['baz', 2.718]

Listeden bir elemanı kaldırabilir misin?

Şöyle bir listemiz olduğunu varsayalım: a = [1, 2, 3, 4, 5]
Verilen listenin ortasındaki “3” elemanını kaldırmak istiyoruz. Böylece a, [1, 2, 4, 5] eşit olacak.

1. a[2:3] = []
2. a.remove(3)
3. a[2] = []
4. a[2:2] = []
5. del a[2]
Cevap

İstediğimiz ifadeyi veren seçenekler 1, 2, 5. Sebeplerine gelince;

del ifadesi istediğimiz indeksteki elemanı kaldırmak için kullanabileceğimiz en basit yöntem.

a[2:3] = []

a[2:3] tek elemandan oluşan, a listesinin bir dilimidir. a[2:3] = [] ile, bu dilimi boş bir liste değiştiriyoruz. Bu da o tek elemanı kaldırmakla sonuçlanıyor.

a.remove(3)

.remove() methodu, eğer belirtilen argüman listede mevcutsa kaldırır. Elemanın listedeki indeksini belirtmek yerine, elemanın değerine göre listeden kaldırmak için güzel bir yöntemdir.

Yanlış cevapların sebeplerine gelince;

a[2:2] = []

a[2:2] boş bir dilim döndürür. a[2:2] = [] a listesi içinde herhangi bir şeyi değiştirmez.

a[2] = []

a[2] dilim değil tek bir elemanı gösterir.Bu sebepten, a[2] = [] ikinci indeksteki elemanı boş bir liste ile değiştirir.

Listenin sonuna eleman ekleyebilir misin?

Şöyle bir listemiz olsun: a = ['a', 'b', 'c']
Bu listenin sonuna “d” ve “e” elemanlarını ekleyeceğiz ve yeni listemiz şuna eşit olacak: ['a', 'b', 'c', 'd', 'e']

1. a.extend(['d', 'e'])
2. a[len(a):] = ['d', 'e']
3. a += ['d', 'e']
4. a.append(['d', 'e'])
5. a[-1:] = ['d', 'e']
6. a += 'de'
Cevap

Doğru cevaplar 1, 2, 3, 6.

a += ['d', 'e']

+= eşitliğin sağında “yinelenebilir” (iterable) olmasını bekler. Listenin elemanlarını sırasıyla döner, soldaki listeye ekler.

a += 'de'

Python, string bir ifade üzerinde dönerken sırasıyla stringin karakterlerini döndürür. Bundan dolayı, bu ifade de listeye ['d', 'e'] ekler.

a.extend(['d', 'e'])

extend() methodu argüman olarak “yinelenebilir” (iterable) bekler ve hedef listeye elemanları ekler.

a[len(a):] = ['d', 'e']

a[len(a):] listenin sonunu gösteren boş bir dilim döndürür. Bu boş dilim listesini ['d', 'e'] ile değiştiriyoruz ve listenin sonuna elemanları eklemiş oluyoruz.

Yanlış cevaplara bakacak olursak;

a.append(['d', 'e'])

append() methodu argüman olarak tek bir nesne alır ve o nesneyi listenin sonuna ekler. Yani yukarıdaki ifade aslında listenin sonuna ['d', 'e'] listesini ekler: ['a', 'b', 'c', ['d', 'e']]

a[-1:] = ['d', 'e']

a[-1:] sadece “c” elemanını içeren liste dilimini döndürür. Yani, yukarıdaki atama ile “c” yi ['d', 'e'] ile değiştirmiş oluyoruz: ['a', 'b', 'd', 'e']

Listenin ortasına eleman ekleyebilir misin?

Şimdiki listemiz şu şekilde: a = [1, 2, 7, 8]
alistesini, “slice assignment” (dilim ataması) kullanarak [1, 2, 3, 4, 5, 6, 7, 8] şeklinde değiştir.

Cevap

a[2:2] = [3, 4, 5, 6]

a[2:2] 2 ve 7 arasında boş bir dilim oluşturur. Bu boş dilime atama yaparak [3, 4, 5, 6] listesini araya eklemiş olduk.

Şöyle bir tuple var:

t = ('foo', 'bar', 'baz')
İkinci eleman olan “bar”ı, “qux” ile değiştirmek istiyoruz. Hangi seçenek ile yapabiliriz?

1. t[1] = 'qux'
2. t(1) = 'qux'
3. t[1:1] = 'qux'
4. Hileli soru. Tuple'ı değiştiremezsin.
Cevap

Doğru cevap: 4.

List ve tuple arasındaki temel fark, tuple’ın değiştirelemez olmasıdır. Yine listelerde olduğu gibi köşeli parentezleri kullanarak indekslere erişebiliriz.

Bir tuple istiyorum;

İçinde tek bir eleman olsun, değeri de ‘foo’ olsun.

Cevap

t = ('foo',)

ya da

t = 'foo',

Eğer t = ('foo') şeklinde yazdıysanız tuple değil string tanımlamış oldunuz. Parentezler içinde tek bir değer belirtmek, tuple tanımlamaz. Bunun için, parentezi kapatmadan önce virgül eklemeniz gerekir.

b’nin değeri nedir?

a, b, c = (1, 2, 3, 4, 5, 6, 7, 8, 9)[1::3]

Cevap

(1, 2, 3, 4, 5, 6, 7, 8, 9)[1::3]

Yukarıdaki kod geriye (2, 5, 8) şeklinde bir tuple oluşturur.

a, b, c = (2, 5, 8) ile bu tuple’ı açıyoruz ve b’nin değeri 5 oluyor.

x ve y’nin değeri nedir?

x = 5
y = -5

x, y = (y, x)[::-1]

1. Değişmez
2. İkiside 5
3. İkiside -5
4. x -5 ve y 5
Cevap

x ve y’nin değeri değişmez çünkü;

(y, x)[::-1] tuple’ı tersine çevirir: (5, -5)

x, y = (5, -5) ile tuple’ı açıyoruz ve x’e 5, y’ye de -5 değerini atıyoruz. Sonuç olarak değerleri aynı kalıyor.

Görüşmek üzere!

Kategori: Python

Yorumlar

Siz de düşüncelerinizi paylaşın

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Back To Top