13 Uygulamalı Özet
Bu sayfa kitapta öğrenilen Python kurallarını, soru çözmeye dönük kısa bir başvuru kâğıdı olarak toplar. En sık karşılaşılan soru tipi, kısa bir programın çıktısını çalıştırmadan bulmaktır; onu bir kurala göre liste oluşturan, döngüyle toplam biriktiren ya da kullanıcıdan güvenli biçimde girdi alan kısa programlar yazmak izler. Sayfa her konu için yazım kalıplarını tablolarla, kodu izlemenin adımlarını, kısa yolları ve en sık düşülen tuzakları verir. Her kısım, yeni değerlerle yazılmış ve çıktısı tam olarak verilmiş çözümlü bir örnekle biter. Her kural, ayrıntısının bulunduğu tanıma ya da bölüme bağlanmıştır.
13.1 Soru Tipine Göre Yöntem
Bir soruyu okuyunca ilk iş, sorunun hangi konuya dokunduğunu ve hangi kuralların devreye gireceğini belirlemektir.
| Soruda istenen | Yöntem | Bu sayfada |
|---|---|---|
| Bir programın çıktısı | Değişken tablosuyla satır satır izleme | Bölüm 13.2 |
Bir değerin tipi, int, float, str, bool dönüşümleri |
Dönüşüm kuralları tablosu | Bölüm 13.3 |
| Uzun bir aritmetik ifadenin değeri | Öncelik sırası; // ve % için bölme eşitliği |
Bölüm 13.4 |
print, sep, end, f-string, kaçış karakterleri |
Varsayılan ayırıcıları tek tek yazmak | Bölüm 13.5 |
Mantık ifadesi, if-elif-else zinciri |
not, sonra and, sonra or; doğru çıkan ilk kol |
Bölüm 13.6 |
| İndeks ve dilim | İndeksleri yazmak; başlangıç dahil, bitiş hariç | Bölüm 13.7 |
| Metotlardan sonra bir listenin son hâli | Yerinde değiştiren metotlar None verir |
Bölüm 13.8 |
for, range, enumerate, zip, toplam ve sayaç |
Yineleme tablosu, biriktirici | Bölüm 13.9 |
| Bir kurala göre liste oluşturmak | Liste üreteci | Bölüm 13.10 |
while, break, continue |
Her denetlemeye bir satır ayıran tablo | Bölüm 13.11 |
| Demet, paketleme ve açma, üreteç ifadesi | Değiştirilemezlik, tükenen üreteç | Bölüm 13.12 |
| Rastgele sayı, seçim, karıştırma | random fonksiyonları tablosu |
Bölüm 13.13 |
| Güvenli girdi almak, bir hatayı bulmak | while True ile try-except; hata türleri tablosu |
Bölüm 13.14 |
13.2 Kod İzleme: Bir Programın Çıktısını Bulmak
Çıktı sorularının hepsi aynı yöntemle çözülür: program, Python’ın yaptığı gibi yukarıdan aşağıya ve her satırı bir kez çalıştırarak kâğıt üzerinde izlenir.
- Değişken tablosu kur. Her değişkene bir sütun aç; her atamadan sonra yeni değeri tipiyle birlikte yaz:
7,7.0ve"7"üç ayrı değerdir. - Önce sağ tarafı hesapla. Atamanın sağ tarafı eski değerlerle tamamen hesaplanır, sonra sola yazılır;
a, b = b, abu yüzden takas yapar (Tanım 2.10). Ardışıka = bveb = aise takas yapmaz; ikisi deb’nin eski değerini alır (Örnek 2.2). - Tipi izle.
/her zamanfloatverir;intilefloatarasındaki her işlemin sonucufloat’tur;inputher zamanstrverir. - Döngüde her yinelemeye bir satır ayır. Döngü değişkeninin, biriktiricinin ve koşulun o yinelemedeki değerini yaz;
breakgelince tabloyu kes,continuegelince satırın geri kalanını atla. - Çıktıyı biçimiyle yaz.
printdeğerleri birer boşlukla ayırır ve satırı bitirir. Tek başına yazdırılan bir metnin tırnakları görünmez; bir listenin ya da demetin içindeki metinler ise tırnaklı ('a') görünür. Bir hata oluşursa program o satırda durur: o ana kadarki çıktılar kalır, ardından hata mesajının son satırı gelir.
Örnek 13.1 (Atamaları Bir Tabloyla İzlemek) Aşağıdaki programın çıktısını bulunuz.
x, y = 17, 5
x %= y
y = y * x - 1
z = y / x
x, y = y, x
print(x, y, z)
print(z * 2, type(z))Çözüm
Her satırdan sonra değişkenlerin değerleri şöyledir:
| Satır | x |
y |
z |
|---|---|---|---|
x, y = 17, 5 |
17 |
5 |
|
x %= y |
2 |
5 |
|
y = y * x - 1 |
2 |
9 |
|
z = y / x |
2 |
9 |
4.5 |
x, y = y, x |
9 |
2 |
4.5 |
\(17 = 3 \cdot 5 + 2\) olduğundan x %= y satırı x’i \(2\) yapar. / bölmesi \(9/2 = 4{,}5\) sonucunu float olarak verir. Son atamada sağ taraf önce eski değerlerle (9, 2) olarak hesaplanır, sonra dağıtılır. z * 2 bir float olduğu için 9.0 yazılır.
9 2 4.5
9.0 <class 'float'>
\(\blacksquare\)
13.3 Tipler ve Dönüşümler
Python’da her değerin bir tipi vardır (Tanım 2.2, Tanım 2.3, Tanım 2.5, Tanım 2.6) ve type(x) bu tipi <class 'int'> biçiminde verir. Tip dönüşüm fonksiyonları (Tanım 2.8) aşağıdaki kurallarla çalışır.
| İfade | Sonuç | Kural |
|---|---|---|
int(7.9), int(-7.9) |
7, -7 |
sıfıra doğru keser, yuvarlamaz |
int("42") |
42 |
rakamlardan oluşan metin sayıya çevrilir |
int("4.2") |
ValueError |
ondalıklı yazım int’e doğrudan çevrilmez |
float(3), float("2.5") |
3.0, 2.5 |
|
str(12) + "3" |
'123' |
iki metin yan yana eklenir |
"12" + 3 |
TypeError |
metin ile sayı + ile birleşmez |
3 * "ab" |
'ababab' |
metin ile tam sayının çarpımı tekrardır |
bool(0), bool(0.0), bool("") |
False |
sıfır ve boş metin yanlış sayılır |
bool("0"), bool(-1), bool(" ") |
True |
geri kalan her değer doğru sayılır |
complex(3, 4) |
(3+4j) |
\(3 + 4i\) |
"2" == 2, 2 == 2.0 |
False, True |
metin ile sayı eşit olmaz; sayılar değere göre karşılaştırılır |
Kısa yollar.
- Ondalıklı yazılmış bir metni tam sayıya çevirmek için önce
float, sonraintuygulanır:int(float("4.2"))\(4\) verir. - Bir sayının rakamlarıyla çalışmak için sayı metne çevrilip harf harf dolaşılır:
sum(int(r) for r in str(n))rakamlar toplamıdır. - Geçerli bir değişken adı harfle ya da
_ile başlar, yalnız harf, rakam ve_içerir ve bir anahtar kelime olamaz (Tanım 2.11).print,sum,listgibi hazır adlar değişkene verilirse o fonksiyon programın geri kalanında çalışmaz.
Örnek 13.2 (Metin mi, Sayı mı?) Aşağıdaki programın çıktısını bulunuz.
a = "4"
b = 2.5
print(a * 3)
print(int(a) * b)
print(int(b) + int(a + "1"))
print(bool(a == 4), str(b) + a)Çözüm
a bir metin, b bir float’tur.
a * 3: metin üç kez yan yana yazılır:444.int(a) * b: \(4 \cdot 2{,}5 = 10{,}0\); birfloatçarpan olduğu için sonuç10.0’dır.int(b) + int(a + "1"):int(2.5)\(2\)’dir;a + "1"metni"41"’dir veintonu \(41\) yapar; toplam \(43\).a == 4: metin ile sayı eşit olmadığındanFalse;bool(False)yineFalse’tur.str(b) + aise"2.5" + "4"birleştirmesidir:2.54.
444
10.0
43
False 2.54
\(\blacksquare\)
13.4 Aritmetik ve İşlem Önceliği
Aritmetik sorularında hata çoğunlukla üç yerde yapılır: bölme türleri, negatif sayıların kalanı ve işlem sırası.
| Operatör | Anlamı | Örnek | Sonuç | Not |
|---|---|---|---|---|
/ |
bölme | 9 / 3 |
3.0 |
sonuç her zaman float |
// |
tam bölme | -9 // 4 |
-3 |
bölümü aşağı yuvarlar |
% |
kalan | -9 % 4 |
3 |
kalan bölenle aynı işaretlidir |
** |
üs alma | 2 ** -2 |
0.25 |
sağdan sola hesaplanır |
Tam bölüm ile kalan her zaman \(a = (a \,//\, b) \cdot b + (a \,\%\, b)\) eşitliğini sağlar (Tanım 3.1). Örneğin \(-9/4 = -2{,}25\) aşağı yuvarlanınca \(-3\) olur ve kalan \(-9 - (-3) \cdot 4 = 3\)’tür.
- Parantezler. En içteki parantezden başla (Tanım 3.2).
- Üsler.
**işlemlerini sağdan sola yap:2 ** 3 ** 2\(2^9 = 512\)’dir. Başa yazılmış eksi işareti üsten sonra uygulanır:-3 ** 2\(-9\)’dur. - Çarpma grubu.
*,/,//ve%işlemlerini soldan sağa yap; her//ve%için yukarıdaki bölme eşitliğini kullan. - Toplama grubu.
+ve-işlemlerini soldan sağa yap. İşlemlerden birindefloatvarsa sonucufloatolarak yaz.
Bir sayıyı tam sayıya indirmenin dört yolu negatif sayılarda ve tam ortadaki sayılarda farklı sonuç verir (Tanım 3.3, Tanım 3.5):
| Fonksiyon | Kural | 2.5 |
-2.5 |
3.7 |
-3.7 |
|---|---|---|---|---|---|
int(x), math.trunc(x) |
sıfıra doğru keser | 2 |
-2 |
3 |
-3 |
math.floor(x) |
aşağı yuvarlar | 2 |
-3 |
3 |
-4 |
math.ceil(x) |
yukarı yuvarlar | 3 |
-2 |
4 |
-3 |
round(x) |
en yakına; tam ortadaysa çift olana | 2 |
-2 |
4 |
-4 |
Kısa yollar.
n % 10son basamağı verir,n // 10son basamağı atar;n % 2 == 0çiftliği,a % b == 0bölünebilmeyi sorar.mathfonksiyonlarıimport mathsatırından sonra kullanılır:math.sqrt,math.factorial,math.comb,math.gcd,math.pi. Trigonometrik fonksiyonlar radyan alır: \(30°\) içinmath.sin(math.radians(30))yazılır.0.1 + 0.2 == 0.3Falseverir; ondalıklı sayılarabs(a - b) < 1e-9biçiminde karşılaştırılır.
- \((-3)^2\) için
(-3) ** 2yazılır;-3 ** 2\(-9\) verir. 1 / 2 * x\(x/2\) demektir; \(\frac{1}{2x}\) için1 / (2 * x)yazılır.10 / 2sonucu5değil5.0’dır; tam sayı sonucu için//kullanılır.
Örnek 13.3 (Kalan, Tam Bölme ve Üs Bir Arada) Aşağıdaki programın çıktısını bulunuz.
a = 3 + 2 ** 2 ** 2 // 5 % 4
b = -17 // 5 + -17 % 5
c = (8 - 2) / 4 * 2 ** -1
print(a, b, c)Çözüm
a. Üsler sağdan sola: 2 ** 2 ** 2 \(= 2^4 = 16\). Ardından soldan sağa 16 // 5 \(= 3\) ve 3 % 4 \(= 3\); en son \(3 + 3 = 6\).
b. Eksi işaretleri \(17\)’lere aittir. \(-17/5 = -3{,}4\) aşağı yuvarlanır: -17 // 5 \(= -4\). Kalan \(-17 - (-4) \cdot 5 = 3\)’tür. Toplam \(-4 + 3 = -1\).
c. Parantez \(6\)’dır; 6 / 4 \(= 1{,}5\), 2 ** -1 \(= 0{,}5\) ve çarpımları \(0{,}75\)’tir.
6 -1 0.75
\(\blacksquare\)
13.5 Yazdırma ve Biçimlendirme
print sorularında en çok, değerlerin arasına ve satır sonuna nelerin yazıldığı sorulur.
| Yazım | Çıktı | Kural |
|---|---|---|
print("a", "b") |
a b |
virgül araya bir boşluk koyar |
print("a" + "b") |
ab |
+ metinleri boşluksuz birleştirir |
print("a", "b", sep="-") |
a-b |
sep değerlerin arasına yazılır (Tanım 4.5) |
print("a", end="!") |
a!, satır bitmez |
end sona yazılır; varsayılanı "\n" |
f"{x:.2f}", x = 2.5 iken |
2.50 |
her zaman tam iki basamak (Tanım 4.6) |
round(2.5, 2) |
2.5 |
round bir sayı verir, sondaki sıfır yazılmaz |
"{1}-{0}".format("a", "b") |
b-a |
sıra numaraları \(0\)’dan başlar |
"%d/%.1f" % (7, 3.14159) |
7/3.1 |
%d tam sayı, %.1f tek basamaklı ondalık, %s metin |
Kaçış karakterleri (Tanım 4.7): \n yeni satır, \t sekme, \\ ters eğik çizginin kendisi, \' ve \" tırnaklar. Çift tırnaklı bir metinde tek tırnak serbestçe kullanılır: "Ali'nin".
Kısa yollar. Değerleri yan yana yazmak için döngüde print(i, end=" "), döngüden sonra satırı bitirmek için boş bir print() yazılır. Bir sonucu cümlenin içine yerleştirmenin en okunaklı yolu f-string’dir: f"Toplam: {a + b}".
print("Toplam: " + 5)TypeErrorverir;print("Toplam:", 5)ya da f-string kullanılır.fharfi unutulursa"{x}"süslü parantezleriyle olduğu gibi yazılır.sepyalnız birden çok değer yazdırılırken etkilidir; tek bir değerde hiçbir şey değiştirmez.
Örnek 13.4 (sep, end ve f-string Bir Arada) Aşağıdaki programın çıktısını bulunuz.
a, b = 7, 3
print(a, b, sep=" / ", end=" = ")
print(f"{a / b:.3f}")
print("Bölüm:", a // b, "kalan", a % b, sep="|")
print("{0}{1}{0}".format("*", a * b))
print("1\t2\n3\\4")Çözüm
- İkinci satır
7ile3’ün arasına/koyar ve sonuna yeni satır yerine=yazar; satır bitmediği için sonrakiprintaynı satırdan devam eder. \(7/3 = 2{,}3333\ldots\) üç basamakla2.333olur. - Dördüncü satırda dört değerin arasına
|konur: \(7 \,//\, 3 = 2\) ve \(7 \,\%\, 3 = 1\). format’ta{0}iki kez*,{1}ise \(21\) ile doldurulur.- Son satırda
\tbir sekme,\nyeni satır,\\tek bir ters eğik çizgidir.
7 / 3 = 2.333
Bölüm:|2|kalan|1
*21*
1 2
3\4
\(\blacksquare\)
13.6 Koşullar ve Mantık Operatörleri
Karşılaştırmalar True ya da False verir (Tanım 5.1) ve matematikteki gibi zincirlenebilir: \(13 \le y < 20\) için 13 <= y < 20 yazılır (Tanım 5.2). Bir ifadede önce karşılaştırmalar, sonra not, sonra and, en son or uygulanır.
and ve or sonucu her zaman iki değerden biri olarak verir; bu değer True ya da False olmak zorunda değildir (Tanım 5.6). Sonuç belli olunca ikinci değere hiç bakılmaz.
| İfade | Sonuç | Neden |
|---|---|---|
3 or 5 |
3 |
ilk değer doğru sayılır, ikinciye bakılmaz |
0 or 5 |
5 |
ilk değer yanlış sayılır, ikinci verilir |
3 and 5 |
5 |
ilk değer doğru sayılır, ikinci verilir |
0 and 5 |
0 |
ilk değer yanlış sayılır, ikinciye bakılmaz |
"" or "boş" |
boş |
boş metin yanlış sayılır |
- Zinciri sırayla dene.
if-elif-elsezincirinde koşullar yukarıdan aşağıya denenir; doğru çıkan ilk kolun bloğu çalışır, geri kalanına bakılmaz (Tanım 5.9). - Önceki koşulları hatırla. Bir
elif’e gelindiyse önceki koşulların hepsi yanlıştır; bu bilgi koşulu kısaltır. - Ayrı
if’leri ayrı say. Alt alta yazılmış ikiifbirbirinden bağımsızdır: ikisi de denetlenir ve ikisi de çalışabilir. Birinciifbir değişkeni değiştirdiyse ikincisi yeni değere bakar.
Kısa yollar.
- İki değerden birini seçen tek satırlık yazım:
a if koşul else b(Tanım 5.10). - Bir değeri birçok sabitle karşılaştırırken
match-casekullanılır;case 6 | 7:iki seçeneği birleştirir,case _:geri kalan her değeri yakalar (Tanım 8.4). - İçi henüz yazılmamış bir blok
passile doldurulur (Tanım 5.11). b != 0 and a / b > 1koşulundabsıfırsa kısa devre sayesinde bölme hiç yapılmaz.
if x = 5:yazım hatasıdır; karşılaştırma==ile yapılır.x == 1 or 2her zaman doğru sayılır, çünkü(x == 1) or 2olarak okunur; doğrusux == 1 or x == 2’dir.- Aralık koşullarında en geniş koşul başa yazılırsa bütün değerler ilk kola düşer; koşullar en dar olandan başlayarak yazılır (Örnek 5.2).
Örnek 13.5 (Bağımsız if ve Bir elif Zinciri) Aşağıdaki programın çıktısını bulunuz.
x = 12
if x % 3 == 0:
x += 1
if x > 10 and not x % 2 == 0:
x *= 2
elif x > 5:
x -= 100
else:
x = 0
print(x, x > 20 or x // 0)Çözüm
\(12\), \(3\)’e bölündüğü için birinci if çalışır ve x \(13\) olur. İkinci if bağımsızdır ve yeni değere bakar: \(13 > 10\) doğrudur; \(13 \,\%\, 2 = 1\) olduğundan x % 2 == 0 yanlıştır ve not onu doğruya çevirir. Koşul doğru çıktığı için x \(26\) olur; elif ve else kollarına bakılmaz.
Son satırda \(26 > 20\) doğrudur. or ilk değer doğru olduğu için True’yu verir ve x // 0 kısmına hiç geçmez; bu yüzden sıfıra bölme hatası oluşmaz.
26 True
\(\blacksquare\)
13.7 İndeksleme ve Dilimleme
\(n\) elemanlı bir listede indeksler baştan \(0, 1, \ldots, n - 1\), sondan \(-1, -2, \ldots, -n\)’dir (Tanım 6.6). s[a:b:c] dilimi a’dan başlar, c’şer ilerler ve b’ye varmadan durur (Tanım 6.7). Aynı kurallar metinlerde ve demetlerde de geçerlidir; bir metnin dilimi metin, bir demetin dilimi demettir.
- İndeksleri yaz. Elemanların altına indekslerini, gerekiyorsa negatif indekslerini yaz.
- Adımın işaretine bak.
cyazılmazsa \(1\)’dir.c > 0ise soldan sağa,c < 0ise sağdan sola gidilir. - Boş uçları doldur.
c > 0iken boşabaş, boşbsondur.c < 0iken boşason eleman, boşbise başın da ötesidir. - Say.
a’dan başla,c’şer ilerle;b’ye varınca ya da onu geçince dur.bindeksli eleman alınmaz.
| Dilim | Anlamı | s = "algoritma" için |
|---|---|---|
s[:3] |
ilk üç eleman | 'alg' |
s[-3:] |
son üç eleman | 'tma' |
s[2:5] |
indeks \(2, 3, 4\) | 'gor' |
s[::2] |
ikişer atlayarak | 'agrta' |
s[1::2] |
tek indeksliler | 'loim' |
s[::-1] |
ters sıra | 'amtirogla' |
s[6:1:-2] |
indeks \(6, 4, 2\) | 'trg' |
s[:-1] |
son eleman hariç | 'algoritm' |
s[5:2] |
pozitif adımda başlangıç bitişten sonra | '' |
Kısa yollar. Adım \(1\) iken s[a:b] diliminde tam \(b - a\) eleman vardır. \(n\) elemanlı bir listede s[-k] ile s[n - k] aynı elemandır. L[:] listenin bağımsız bir kopyasıdır. Bir metnin palindrom olup olmadığı s == s[::-1] ile sorulur.
L[1]bir elemandır,L[1:2]ise tek elemanlı bir listedir:20ile[20]farklıdır.- Negatif adımda başlangıç bitişten büyük olmalıdır;
L[1:5:-1]boş listedir. L[len(L)]IndexErrorverir; son elemanL[-1]’dir. Dilimler ise sınırı aşsa da hata vermez:"algoritma"[3:100]'oritma'’dır.
Örnek 13.6 (Bir Listeden Dilimler) Aşağıdaki programın çıktısını bulunuz.
L = [4, 8, 15, 16, 23, 42]
print(L[1:4], L[-2:], L[::3])
print(L[4:0:-2], L[::-2])
print(L[2] + L[-1], L[1:2] * 2)Çözüm
İndeksler: 4 \(0\), 8 \(1\), 15 \(2\), 16 \(3\), 23 \(4\), 42 \(5\).
L[1:4]: indeks \(1, 2, 3\).L[-2:]: son iki eleman.L[::3]: indeks \(0, 3\).L[4:0:-2]: \(4\)’ten başlayıp ikişer geri, \(0\)’a varmadan: indeks \(4, 2\).L[::-2]: sondan başlayıp ikişer geri: indeks \(5, 3, 1\).L[2] + L[-1]\(= 15 + 42 = 57\).L[1:2][8]listesidir; bir listenin \(2\) ile çarpımı onu iki kez yan yana yazar.
[8, 15, 16] [23, 42] [4, 16]
[23, 15] [42, 16, 8]
57 [8, 8]
\(\blacksquare\)
13.8 Liste Metotları ve Kopyalama
Liste sorularında belirleyici soru, bir işlemin listenin kendisini mi değiştirdiği, yoksa yeni bir değer mi verdiğidir (Tanım 6.5).
| Yazım | Listeyi değiştirir mi? | Verdiği değer |
|---|---|---|
L.append(x) |
evet; x sona tek eleman olarak eklenir |
None |
L.extend(K) |
evet; K’nin elemanları tek tek eklenir |
None |
L.insert(i, x) |
evet; x indeks i’ye girer |
None |
L.remove(x) |
evet; değeri x olan ilk eleman silinir |
None |
L.pop(i), L.pop() |
evet; indeks i’deki ya da son eleman çıkar |
çıkan eleman |
del L[i], L.clear() |
evet | |
L.sort(), L.reverse() |
evet | None |
sorted(L), list(reversed(L)) |
hayır | yeni bir liste |
L + K, 3 * L |
hayır | yeni bir liste |
L.count(x), L.index(x), x in L |
hayır | sayı, indeks, bool |
Dört koleksiyonun farkı (Tanım 6.1, Tanım 6.2, Tanım 6.3, Tanım 6.4): liste [1, 2] sıralı ve değiştirilebilir; demet (1, 2) sıralı ama değiştirilemez; küme {1, 2} sırasızdır ve tekrar eden elemanı tutmaz; sözlük {"a": 1} değerlere anahtarla erişir. set(L) bir listedeki farklı elemanları bulmanın kısa yoludur.
Kopyalama. b = a listeyi kopyalamaz, aynı listeye ikinci bir ad verir; b üzerinden yapılan her değişiklik a’da da görünür. Bağımsız bir kopya için b = a.copy() ya da b = a[:] yazılır.
L = L.sort()listeyi kaybettirir:sortNoneverir veLartıkNone’dır. Sıralı bir kopya isteniyorsasorted(L)kullanılır.L.append([4, 5])iç içe bir liste oluşturur; elemanları tek tek eklemek içinextendkullanılır.3 * Lelemanları çarpmaz, listeyi tekrarlar; elemanları çarpmak için[3 * x for x in L]yazılır.removedeğere,popvedelindekse göre siler.L.index(x)xlistede yoksa hata verir; öncex in Lile sorulur (Tanım 6.8).
Örnek 13.7 (Metotlar ve Aynı Listeye İki Ad) Aşağıdaki programın çıktısını bulunuz.
a = [5, 1, 4]
b = a
c = a[:]
b.append(2)
c.extend([9, 9])
x = a.pop(0)
y = a.sort()
print(a, b, c)
print(x, y, c.count(9), sorted(c)[:2])Çözüm
b ile a aynı listedir; c ise o anki hâlin bağımsız bir kopyasıdır: [5, 1, 4].
| Satır | a ve b |
c |
|---|---|---|
b.append(2) |
[5, 1, 4, 2] |
[5, 1, 4] |
c.extend([9, 9]) |
[5, 1, 4, 2] |
[5, 1, 4, 9, 9] |
x = a.pop(0) |
[1, 4, 2] |
[5, 1, 4, 9, 9] |
y = a.sort() |
[1, 2, 4] |
[5, 1, 4, 9, 9] |
pop(0) çıkardığı \(5\)’i verir, bu yüzden x \(5\)’tir. sort listeyi yerinde sıralar ve None verir. c’de iki tane \(9\) vardır; sorted(c) [1, 4, 5, 9, 9] listesidir ve ilk iki elemanı [1, 4]’tür.
[1, 2, 4] [1, 2, 4] [5, 1, 4, 9, 9]
5 None 2 [1, 4]
\(\blacksquare\)
13.9 for Döngüsü, range, enumerate ve zip
for döngüsü bir koleksiyonun elemanlarını sırayla döngü değişkenine atar ve her biri için bloğu bir kez çalıştırır (Tanım 7.1). range(a, b, c) a’dan başlayıp c’şer ilerleyen ve b’ye varmadan duran tam sayıları verir (Tanım 6.9).
| Çağrı | Verdiği sayılar |
|---|---|
range(5) |
\(0, 1, 2, 3, 4\) |
range(2, 6) |
\(2, 3, 4, 5\) |
range(1, 10, 3) |
\(1, 4, 7\) |
range(10, 0, -3) |
\(10, 7, 4, 1\) |
range(5, 1) |
hiç sayı yok |
| Döngü | Döngü değişkeninin aldığı değerler |
|---|---|
for x in L: |
elemanlar |
for h in "abc": |
karakterler |
for k in sozluk: |
anahtarlar; sozluk.values() değerleri, sozluk.items() anahtar–değer çiftlerini verir |
for i, x in enumerate(L): |
indeks ve eleman (Tanım 7.5) |
for x, y in zip(L, K): |
aynı sıradaki çiftler; kısa olan bitince durur (Tanım 7.6) |
for _ in range(n): |
değer kullanılmaz; iş \(n\) kez yapılır (Tanım 7.4) |
- Başlangıç değeri. Döngüden önce biriktiriciye başlangıç değeri ver: toplam ve sayaç için
0, çarpım için1, liste için[](Tanım 7.2). - Güncelleme. Döngünün içinde, gerekiyorsa bir
ifile süzerektoplam += x,carpim *= x,sayac += 1ya daliste.append(x)yaz. - Sonuç. Sonucu döngüden sonra, girintisiz bir satırda yazdır; ortalama gibi değerler de döngü bittikten sonra hesaplanır.
break döngüyü hemen bitirir, continue yalnız o yinelemenin geri kalanını atlar (Tanım 7.3). İç içe döngülerde ikisi de yalnız içinde bulundukları döngüyü etkiler (Tanım 8.1).
- Biriktiriciyi döngünün içinde başlatmak: her yinelemede sıfırlanır ve sonuçta yalnız son eleman kalır.
range(1, n)\(n\)’yi içermez; \(1\)’den \(n\)’ye kadar sayılar içinrange(1, n + 1)yazılır.- Döngü değişkenine döngünün içinde yeni bir değer atamak yalnız o yinelemeyi etkiler; sonraki yinelemede değişken yine sıradaki elemanı alır (Alıştırma 11.27).
- Döngüden sonra yazılması gereken
print’i girintili yazmak, onu her yinelemede çalıştırır.
Örnek 13.8 (İç İçe Döngüde break) Aşağıdaki programın çıktısını bulunuz.
sonuc = []
for i in range(1, 4):
for j in range(i, 5):
if (i + j) % 4 == 0:
break
sonuc.append(i * j)
print(sonuc, len(sonuc))Çözüm
Dıştaki döngü \(i = 1, 2, 3\) değerlerini alır; içteki döngü her \(i\) için \(j = i, \ldots, 4\) değerlerini dener. break yalnız içteki döngüyü bitirir.
i |
j |
(i + j) % 4 |
Yapılan |
|---|---|---|---|
| \(1\) | \(1\) | \(2\) | \(1\) eklenir |
| \(1\) | \(2\) | \(3\) | \(2\) eklenir |
| \(1\) | \(3\) | \(0\) | break |
| \(2\) | \(2\) | \(0\) | break |
| \(3\) | \(3\) | \(2\) | \(9\) eklenir |
| \(3\) | \(4\) | \(3\) | \(12\) eklenir |
\(i = 2\) için içteki döngü ilk adımda bitti, ama dıştaki döngü \(i = 3\) ile devam etti.
[1, 2, 9, 12] 4
\(\blacksquare\)
13.10 Liste Üreteçleri
Boş bir listeyi bir döngüyle doldurmanın tek satırlık yazımı liste üretecidir (Tanım 7.7).
| Yazım | Anlamı | Örnek | Sonuç |
|---|---|---|---|
[ifade for x in K] |
her eleman dönüştürülür | [x ** 2 for x in range(4)] |
[0, 1, 4, 9] |
[ifade for x in K if koşul] |
koşulu sağlayanlar alınır | [x for x in range(10) if x % 4 == 1] |
[1, 5, 9] |
[a if koşul else b for x in K] |
her eleman girer, değeri koşula bağlıdır | [0 if x < 2 else x for x in range(4)] |
[0, 0, 2, 3] |
[ifade for x in A for y in B] |
sondaki for içteki döngüdür |
[x * y for x in (1, 2) for y in (1, 10)] |
[1, 10, 2, 20] |
sum(ifade for x in K) |
liste kurmadan toplar | sum(x for x in range(5)) |
10 |
sonuc = []satırını veforsatırını köşeli parantezin içine taşı.appendiçindeki ifadeyi parantezin başına yaz.- Elemanı süzen bir
ifvarsa sona; elemanın değerini seçen birif-elsevarsa başa yaz.
- Sondaki süzgeç
if’ielsealmaz:[x for x in L if x > 0 else 0]SyntaxErrorverir. Her eleman bir değerle girecekse[x if x > 0 else 0 for x in L]yazılır. - Liste üreteci içinde
printya dabreakkullanılmaz; böyle işler için açık birfordöngüsü yazılır.
Örnek 13.9 (Süzen, Seçen ve Eşleyen Üreteçler) Aşağıdaki programın çıktısını bulunuz.
L = [3, -1, 4, -1, 5, -9]
A = [x * x for x in L if x < 0]
B = ["+" if x > 0 else "-" for x in L]
C = [i for i, x in enumerate(L) if x == -1]
D = [x + y for x, y in zip(L, L[1:])]
print(A, sum(A))
print(B)
print(C, D)Çözüm
A: yalnız negatif elemanlar \(-1, -1, -9\) alınır ve kareleri yazılır:[1, 1, 81]; toplamları \(83\).B: her eleman listeye girer; pozitifse"+", değilse"-"olur.C:enumerateindeksleri verir; \(-1\), indeks \(1\) ve \(3\)’tedir.D:L[1:]listesiL’nin bir sola kaymış hâlidir;zipardışık elemanları eşler ve kısa olan bitince durur. Çiftler \((3, -1)\), \((-1, 4)\), \((4, -1)\), \((-1, 5)\), \((5, -9)\), toplamları \(2, 3, 3, 4, -4\)’tür.
[1, 1, 81] 83
['+', '-', '+', '-', '+', '-']
[1, 3] [2, 3, 3, 4, -4]
\(\blacksquare\)
13.11 while Döngüsü
while koşul: bloğu, koşul her denetlendiğinde doğru çıktığı sürece tekrarlanır (Tanım 8.2). Tekrar sayısı belliyse for, kaç tur döneceği önceden bilinmiyorsa while kullanılır; bitiş denetimi bloğun ortasında yapılacaksa while True: yazılır ve uygun yerde break ile çıkılır (Tanım 8.3).
- Tablo kur. Her koşul denetlemesine bir satır ayır: koşulun değeri, değişkenler ve o turdaki çıktı.
- Önce koşulu denetle. Koşul yanlışsa döngüden çık; ilk denetlemede yanlışsa blok hiç çalışmaz.
- Bloğu satır satır uygula.
continuegelince hemen koşula dön;breakgelince döngüden çık. - Son değerleri yaz. Döngüden sonra sayaç, koşulu bozan değerde kalır:
while i <= 5döngüsüi\(6\) iken biter.
Kısa yollar.
- Bir sayının rakamlarını sağdan sola ayırmak:
r = n % 10ile rakamı al,n //= 10ile at; döngüwhile n > 0:ile kurulur (Alıştırma 8.1). - Öklid algoritması:
while b != 0: a, b = b, a % bdöngüsü bittiğindeaEBOB’dur (Alıştırma 8.2).
- Koşuldaki değişkeni bloğun içinde güncellemeyi unutmak sonsuz döngü kurar.
- Güncelleme
continue’dan sonra yazılırsacontinueonu da atlar ve döngü takılır; güncellemecontinue’dan önce yapılmalıdır. <ile<=arasındaki fark bir tur fark ettirir; son turu tabloda ayrıca denetleyin.
Örnek 13.10 (Rakamları Ayıran Bir while Döngüsü) Aşağıdaki programın çıktısını bulunuz.
n = 40723
toplam = 0
adim = 0
while n > 0:
r = n % 10
n //= 10
if r == 0:
continue
toplam += r
adim += 1
print(toplam, adim, n)Çözüm
Her turda son rakam r’ye alınır ve n’den atılır; sıfır rakamı continue ile atlanır. n continue’dan önce güncellendiği için döngü takılmaz.
| Denetleme | n > 0 |
r |
Turdan sonra n |
toplam |
adim |
|---|---|---|---|---|---|
| \(1\) | True |
\(3\) | \(4072\) | \(3\) | \(1\) |
| \(2\) | True |
\(2\) | \(407\) | \(5\) | \(2\) |
| \(3\) | True |
\(7\) | \(40\) | \(12\) | \(3\) |
| \(4\) | True |
\(0\) | \(4\) | \(12\) | \(3\) |
| \(5\) | True |
\(4\) | \(0\) | \(16\) | \(4\) |
| \(6\) | False |
16 4 0
\(\blacksquare\)
13.12 Demetler ve Üreteç İfadeleri
Demetler listeler gibi indekslenir ve dilimlenir; farkları, oluşturulduktan sonra değiştirilememeleridir (Tanım 9.2).
| Yazım | Sonuç | Kural |
|---|---|---|
t = 3, 7 |
(3, 7) |
demeti parantez değil virgül oluşturur (Tanım 9.1) |
(5), (5,), () |
5, (5,), () |
tek elemanlı demette virgül şarttır |
a, b = t |
a = 3, b = 7 |
açma; iki taraftaki sayılar eşit olmalıdır |
ilk, *orta, son = [1, 2, 3, 4] |
orta = [2, 3] |
yıldızlı değişken kalanları liste olarak alır |
t[0] = 1 |
TypeError |
demetin elemanı değiştirilemez |
t + (9,), t * 2 |
(3, 7, 9), (3, 7, 3, 7) |
yeni demet oluşur, eskisi değişmez |
sorted((3, 1, 2)) |
[1, 2, 3] |
sıralamanın sonucu her zaman listedir |
t.count(x), t.index(x) |
sayı, indeks | demetin yalnız bu iki metodu vardır |
(x * 2 for x in K) |
üreteç | değerleri bir kez üretir, sonra tükenir (Tanım 9.3) |
Bir demeti değiştirmek. Demet list ile listeye çevrilir, liste değiştirilir ve sonuç tuple ile yeniden demete çevrilip aynı ada atanır: L = list(t), L[0] = 1, t = tuple(L).
Örnek 13.11 (Paketleme, Açma ve Tükenen Üreteç) Aşağıdaki programın çıktısını bulunuz.
t = 2, 5, 8
a, *b = t
t = t + (a,)
g = (x * 10 for x in b)
print(t, b, type(t))
print(sum(g), sum(g))
print(t.count(2), t.index(5), (a), (a,))Çözüm
t = 2, 5, 8virgüllerle bir demet paketler.a, *b = taçmasındaa\(2\)’yi, yıldızlıbkalanları liste olarak alır:[5, 8].t + (a,)yeni bir demettir:(2, 5, 8, 2); aynı ada atandığı içintartık bu demettir.gbir üreteçtir. İlksum(g)\(50 + 80 = 130\)’u verir ve üreteci tüketir; ikincisum(g)hiç değer bulamaz ve \(0\) verir.t’de \(2\) iki kez geçer; \(5\)’in indeksi \(1\)’dir.(a)yalnız bir gruplamadır ve \(2\) sayısının kendisidir;(a,)ise tek elemanlı demettir.
(2, 5, 8, 2) [5, 8] <class 'tuple'>
130 0
2 1 2 (2,)
\(\blacksquare\)
13.13 random Modülü
random modülü import random ile programa alınır; fonksiyonları random.randint(...) biçiminde çağrılır. Üretilen sayılar sözde rastgeledir ve aynı tohumla aynı dizi yeniden elde edilir (Tanım 10.2).
| Çağrı | Verdiği değer | Uçlar ve tekrar |
|---|---|---|
random.random() |
\([0, 1)\) aralığında bir float |
\(1\) dahil değil |
random.uniform(a, b) |
\(a\) ile \(b\) arasında bir float |
|
random.randint(a, b) |
\(a\) ile \(b\) arasında bir tam sayı | iki uç da dahil |
random.randrange(a, b, c) |
range(a, b, c) sayılarından biri |
b dahil değil |
random.choice(K) |
K’den bir eleman |
|
random.choices(K, k=n) |
n elemanlı bir liste |
iadeli: tekrar olabilir (Tanım 10.3) |
random.sample(K, k) |
k farklı elemanlı bir liste |
iadesiz: tekrar olmaz |
random.shuffle(L) |
None; L yerinde karışır |
|
random.gauss(mu, sigma) |
normal dağılımdan bir float |
|
random.seed(a) |
tohumu belirler | aynı tohum, aynı dizi |
Kısa yollar. Zar: random.randint(1, 6). Yazı tura: random.choice(["Yazı", "Tura"]). \(0\) ile \(100\) arasında rastgele bir çift sayı: random.randrange(0, 101, 2). \(n\) zar atışı: [random.randint(1, 6) for _ in range(n)]. Asıl listeyi bozmadan karışık bir kopya: random.sample(L, len(L)).
random.randrange(1, 6)\(6\)’yı hiçbir zaman vermez; zar içinrandint(1, 6)ya darandrange(1, 7)yazılır.L = random.shuffle(L)listeyi kaybettirir, çünküshuffleNoneverir.random.sample(L, k)çağrısındak,L’nin eleman sayısından büyükseValueErroroluşur.
Örnek 13.12 (Hangi Değerler Gelebilir?) import random satırından sonra random.randint(2, 5), random.randrange(2, 5), random.randrange(10, 0, -3), random.choice("ada") ve random.sample(range(1, 4), 2) çağrılarının her biri hangi değerleri verebilir?
Çözüm
Her çağrının olası değerleri, ilgili kuraldan okunur:
randint(2, 5): iki uç da dahildir: \(2, 3, 4, 5\).randrange(2, 5):range(2, 5)sayılarından biridir ve \(5\) dahil değildir: \(2, 3, 4\).randrange(10, 0, -3):range(10, 0, -3)sayıları \(10, 7, 4, 1\)’dir; bunlardan biri gelir.choice("ada"): metnin karakterlerinden biri seçilir:'a'ya da'd'.'a'iki kez geçtiği için seçilme olasılığı \(2/3\)’tür.sample(range(1, 4), 2): \(1, 2, 3\) sayılarından iki farklı sayı sırasıyla seçilir; olası listeler[1, 2],[2, 1],[1, 3],[3, 1],[2, 3],[3, 2]’dir.[2, 2]gibi bir liste gelemez, çünkü seçim iadesizdir.
\(\blacksquare\)
13.14 Girdi Almak ve Hataları Bulmak
input kullanıcının yazdığını her zaman metin olarak verir (Tanım 4.1); sayıyla hesap yapmadan önce int ya da float ile çevrilir. Çevirme başarısız olabileceği için güvenli bir program hatayı try-except ile yakalar (Tanım 4.3) ve while True ile soruyu geçerli bir değer gelene kadar yineler. Aşağıdaki çıktıda on, -3 ve 12 kullanıcının yazdığı değerlerdir.
while True:
try:
n = int(input("Pozitif bir tam sayı: "))
if n > 0:
break
print("Sayı pozitif olmalı.")
except ValueError:
print("Bu bir tam sayı değil.")
print("Girilen:", n)Pozitif bir tam sayı: on
Bu bir tam sayı değil.
Pozitif bir tam sayı: -3
Sayı pozitif olmalı.
Pozitif bir tam sayı: 12
Girilen: 12
Bir hata oluştuğunda mesajın son satırı hatanın türünü söyler. Aşağıdaki tablo en sık görülen hataları, onlara yol açan tipik yazımla eşleştirir.
| Tipik yazım | Hata | Düzeltme |
|---|---|---|
print("Yaş: " + 20) |
TypeError |
print("Yaş:", 20) ya da str(20) |
int("3.5"), int("on") |
ValueError |
float(...) ya da try-except |
if x > 0 (iki nokta yok) |
SyntaxError |
if x > 0: |
if’ten sonra girintisiz satır |
IndentationError |
bloğu dört boşlukla girintilemek |
print(toplm) |
NameError |
adı düzeltmek; büyük ve küçük harf farklıdır |
math.sqrt(9), import yok |
NameError |
önce import math |
import Math |
ModuleNotFoundError |
import math |
L[len(L)] |
IndexError |
son eleman L[-1] |
sozluk["yok"] |
KeyError |
anahtarı önce in ile sormak |
(1, 2).append(3) |
AttributeError |
demeti listeye çevirmek |
t[0] = 5, t bir demet |
TypeError |
yeni bir demet oluşturmak |
x / 0, x % 0 |
ZeroDivisionError |
böleni önce denetlemek |
Bir hatayı bulmak için önce mesajın son satırındaki hata türü okunur, sonra mesajın gösterdiği satıra gidilir; neden hâlâ belli değilse hatalı satırdan önce print(type(x)) gibi satırlar eklenerek değişkenlerin değeri ve tipi yazdırılır (Örnek 4.2).
Örnek 13.13 (İndirimli Fiyat Programındaki Hatalar) Aşağıdaki program kullanıcıdan bir fiyat alıp yüzde yirmi indirimli fiyatı yazmak istiyor. Kullanıcı 250 yazdığında program çalışmıyor. Hataları bulunuz ve programı düzeltiniz.
fiyat = input("Fiyat: ")
indirim = 0.2
yeni = fiyat * (1 - indirim)
print("İndirimli fiyat: " + yeni)Çözüm
Birinci hata. Program çalıştırılınca şu çıktı alınır:
Fiyat: 250
TypeError: can't multiply sequence by non-int of type 'float'
Hata üçüncü satırdadır: input bir metin verdiği için fiyat "250" metnidir ve bir metin bir float ile çarpılamaz. Girdi float(input("Fiyat: ")) ile sayıya çevrilir.
İkinci hata. Bu düzeltmeden sonra hesap yapılır, ama dördüncü satır bu kez TypeError: can only concatenate str (not "float") to str hatasını verir: bir metin ile bir float + ile birleştirilemez. Sonucu cümleye f-string ile yerleştirir ve iki basamakla yazarız:
fiyat = float(input("Fiyat: "))
indirim = 0.2
yeni = fiyat * (1 - indirim)
print(f"İndirimli fiyat: {yeni:.2f}")Fiyat: 250
İndirimli fiyat: 200.00
\(250 \cdot 0{,}8 = 200\) olduğundan sonuç doğrudur.
\(\blacksquare\)