Şimdiye kadar incelediğimiz tüm bileşik tipler -- karakter dizileri, listeler, ve çok öğeliler (tuple) -- ardışık tiplerdir, içerdikleri değerlere erişmek için tamsayılar indis olarak kullanılır.
Sözlükler farklı bileşik tiplerdir. Python'un yerleşik eşleştirme tipidir. Değişmez, sabit olan Anahtarları (key) herhangi bir tipteki değerlere eşler, aynı çok öğeli veya listelerdeki değerler gibi.
Örnek olarak, Türkçe kelimeleri İspanyolca'ya çeviren bir sözlük yaratacağız. Bu sözlük için anahtarlar karakter dizisidir.
Sözlük yaratmanın bir yolu boş bir sözlükle başlamak ve daha sonra anahtar-değer çiftleri eklemektir. Boş sözlük {}
ile gösterilmektedir:
>>> tr2sp = {} >>> tr2sp['bir'] = 'uno' >>> tr2sp['ikıi'] = 'dos'
İlk atama tr2sp
adında bir sözlük yaratır; diğer atamalar sözlüğe yeni anahtar-değer çiftlerini ekler. Sözlüğün geçerli değerini her zamanki gibi yazdırabiliriz:
>>> print tr2sp {'iki': 'dos', 'bir': 'uno'}
Sözlükteki anahtar-değer çiftleri virgülle ayrılmıştır. Her çift iki nokta üstüste ile ayrılmış bir anahtar ve değer içerir.
Çiftlerin sırası beklendiği gibi olmayabilir. Python sözlükte anahtar-değer çiftlerinin nerede saklanacağını belirlemek için karmaşık algoritmalar kullanır. Amaçlarımız açısından bu sıralamanın önceden kestirilemeyen olduğunu düşünebiliriz
Sözlük yaratmanın bir diğer yolu önceki çıktıda gördüğümüz sözdiziminde anahtar-değer çiftlerinden oluşan bir liste sağlamaktır::
>>> tr2sp = {'bir': 'uno', 'iki': 'dos', 'üç': 'tres'}
Çiftlerin yazılış sırasının önemi yoktur. Sözlükteki değerlere anahtarlarla erişilir, indislerle değil. Bu yüzden sıralamayla uğraşmaya gerek yoktur.
Aşağıdaki ilgili değeri bulmak için anahtarın nasıl kullanıldığını görebilirsiniz:
>>> print tr2sp['iki'] 'dos'
'iki'
anahtarı 'dos'
değerini döndürmektedir.
12.1 Sözlük işlemleri
del
ifadesi sözlükten anahtar-değer çiftini siler. Örneğin aşağıdaki sözlük meyve isimlerini ve her meyvenin stoktaki miktarını tutmaktadır:
>>> stok = {'elma': 430, 'muz': 312, 'portakal': 525, 'erik': 217} >>> print stok {'portakal': 525, 'elma': 430, 'erik': 217, 'muz': 312}
Eğer birisi tüm erikleri satın alırsa, ilgili kaydı sözlükten silebiliriz:
>>> del stok['erik'] >>> print stok {'portakal': 525, 'elma': 430, 'muz': 312}
Eğer yakın zamanda daha fazla erik gelmesini bekliyorsak, sadece eriklerin değerini değiştiririz:
>>> stok['erik'] = 0 >>> print stok {'portakal': 525, 'elma': 430, 'erik': 0, 'muz': 312}
len
işlemi sözlüklerde de çalışır; anahtar-değer çiftlerinin sayısını döndürür:
>>> len(stok) 4
12.2 Sözlük metotları
Sözlükler bazı yararlı yerleşik metotlara sahiptir.
keys
metotu bir sözlük parametresi alır ve o sözlüğün anahtarlarını döndürür.
>>> tr2sp.keys() ['üç', 'iki', 'bir']
Karakter dizileri ve listelerde gördüğümüz gibi, sözlük metotları da nokta gösterimini kullanır. Noktanın sağına metotun ismi yazılır ve noktanın solundaki değişkene ilgili metotu uygular. Parantezler bu metotun parametre almadığını belirtir.
Metot çağrımına çağırma (invocation) adı verilir, tr2sp
nesnesinde keys
metodunu çağırdığımızı söyleriz. Nesne yönelimli programlama ile ilgili bölümü incelediğimizde, nesnenin çağrılan metotunun, metotun ilk argümanı olduğunu da göreceğiz.
values
metotu benzerdir; sözlükteki değerlerin bir listesini döndürür
>>> tr2sp.values() ['tres', 'dos', 'uno']
items
metotu hem anahtarları hem de değerleri, çok öğeli (tuple) liste şeklinde döndürür:
>>> tr2sp.items() [('üç', 'tres'), ('iki', 'dos'), ('bir', 'uno')]
has_key
metotu argüman olarak bir anahtar alır ve eğer sözlük anahtarı içeriyorsaTrue
içermiyorsa False
değerini döndürür:
>>> tr2sp.has_key('bir') True >>> tr2sp.has_key('deux') False
Bu metot çok yararlı olabilir, çünkü sözlükte olmayan bir anahtara erişmek çalışma zamanı hatasına yol açar:
>>> tr2esp['dog'] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'dog' >>>
12.3 Rumuz ve kopyalama
Sözlükler değiştirilebilir olduğu için rumuz kullanımına karşı dikkatli olmalısınız. Ne zaman iki değişken aynı nesneyi gösterirse, herhangi birine yapılan değişiklikler diğerini de etkiler.
Eğer sözlüğünüzü değiştirmek ama asılın bir kopyasını saklamak istiyorsanız, copy
metotunu kullanmalısınız. Örneğin, karsitlar
karşıt çiftleri içeren bir sözlük olsun:
>>> karsitlar = {'up': 'down', 'right': 'wrong', 'true': 'false'} >>> rumuz = karsitlar >>> kopya = karsitlar.copy()
rumuz
ve karsitlar
aynı nesneyi göstermektedir;
kopya
ise aynı sözlüğün yeni bir kopyasını göstermektedir. Eğer rumuzu
değiştirirsek, karsitlar
da değişecektir:
>>> rumuz['right'] = 'left' >>> karsitlar['right'] 'left'
Eğer kopya
yı değiştirirsek, karsitlar
değişmeyecektir:
>>> kopya['right'] = 'privilege' >>> karsitlar['right'] 'left'
12.4 Dağınık matrisler
Daha önce bir matrisi temsil etmek için listelerden oluşan liste kullanmıştık. Bu genellikle sıfırdan farklı değerler içeren matrisler için iyi bir çözümdür, ancak aşağıdaki gibi bir dağınık matrisi düşünün:
Liste temsili çok sayıda sıfır içerecektir:
matris = [[0, 0, 0, 1, 0], [0, 0, 0, 0, 0], [0, 2, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 3, 0]]
Alternatif bir yöntem sözlük kullanmaktır. Anahtarlar için satır ve sütun numalarını içeren tuple kullanabiliriz. Aşağıda aynı matrisin sözlük gösterimini görebilirsiniz:
matris = {(0, 3): 1, (2, 1): 2, (4, 3): 3}
Sadece üç anahtar-değer çiftine sahibiz, matriste sıfır olmayan her bir öğe için. Her bir anahtar iki tamsayı içeren bir tuple'dan oluşuyor.
Matrisin öğelerine erişmek için, []
işlecini kullanabiliriz:
matris[(0, 3)] 1
Dikkat ederseniz sözlük gösterimi söz dizimi içiçe liste sözdiziminden farklıdır. İki farklı tamsayı indis yerine, bir indisimiz, tamsayılardan oluşan tuple indisimiz var.
Ancak bir sorunumuz var. Eğer sıfır olan bir öğeyi belirtmek istersek, hatayla karşılaşırız, çünkü sözlükte o anahtarın girdisi yok:
>>> matris[(1, 3)] KeyError: (1, 3)
get
metotu bu sorunu çözer:
>>> matris.get((0, 3), 0) 1
İlk argüman anahtardır; ikinci argüman ise anahtarın sözlükte olmaması durumunda get
tarafından geri döndürülecek değerdir:
>>> matris.get((1, 3), 0) 0
get
dağınık matrise erişmenin sözdizimini bariz bir şekilde iyileştirir.
12.5 İpuçları
Son bölümdeki fibonacci
fonksiyonuyla biraz uğraşırsanız, daha büyük argümanların fonksiyonun çalışmasını daha da uzattığını görürsünüz. Çalışma zamanı oldukça hızlı bir şekilde artmaktadır. Bir makinemize, fibonacci(20)
anında biterken, fibonacci(30)
yaklaşık olarak 1 sn, ve fibonacci(40)
ise neredeyse sonsuz süre almaktadır.
Bunun neden olduğunu anlamak için, fibonacci
fonksiyonunun n = 4
için çağrı çizgesini incelemek lazım:
Çağrı çizgesi fonksiyon çerçeve kümeleriyle, her çerçeveyi çağırdığı fonksiyonun çerçevelerine bağlayan doğruları gösterir. Çizgenini tepesinde fibonacci
n = 4
ve fibonacci
n = 3
'ü çağırmaktadır. fibonacci
n = 3
'te fibonnaci
n = 2
ve fibonnaci
n = 1
'i çağırmaktadır. Bu böyle devam eder.
fibonacci(0)
ve fibonacci(1)
'in kaç kere çağrıldığını sayın. Bu problemin verimsiz bir çözümüdür, ve problemin argümanı büyüdükçe çözüm kötüleşmektedir.
İyi bir çözüm daha önceden hesaplanmış değerlerin bir sözlükte saklanmasıdır. Sonradan çağrılmak üzere saklanmış önceden hesaplanmış bir değer ipucu (hint) adını almaktadır. Aşağıda fibonacci
fonksiyonunun ipuçlarıyla gerçekleştirimini görebilirsiniz:
onceki = {0: 0, 1: 1} def fibonacci(n): if onceki.has_key(n): return onceki[n] else: yeni_deger = fibonacci(n-1) + fibonacci(n-2) onceki[n] = yeni_deger return yeni_deger
onceki
adını verdiğimiz sözlük, hali hazırda bildiğimiz Fibonacci sayılarını tutmaktadır. Sadece iki çiftle başlarız: 0 1'e eşlenir ve 1 1'e eşlenir.
Her ne zamanfibonacci
çağrılırsa, önce sözlükte değer var mı diye kontrol eder. Eğer değer varsa, herhangi özyineli bir çağrım yapmadan fonksiyon değeri döndürebilir. Eğer yoksa, yeni değeri hesaplaması gerekir. Yeni değer fonksiyon değer döndürmeden önce sözlüğe eklenir.
Bu fibonacci
sürümünü kullanarak, makinelerimizin bir göz kırpımında fibonacci(100)
'ü hesaplamasını sağlayabiliriz.
>>> fibonacci(100) 354224848179261915075L
Numaranın sonundaki L
ifadesi değerin bir uzun tamsayı
olduğunu belirtmektedir.
12.6 Uzun tamsayılar
Python herhangi bir büyüklükteki (elbette makinenizin belleğiyle sınırlıdır :) ) tamsayıyı desteklemek için long
(uzun tamsayı) tipini sunmaktadır.
Uzun tamsayı değeri oluşturmanın üç yolu vardur. İlki normal bir tamsayıya sığmayacak çok büyük değer üreten bir aritmetik deyim hesaplamaktadır. Bunu daha önce fibonacci(100)
örneğinde gördük. Bir başka yöntem tamsayının sağına L
harfini koymaktır:
>>> type(1L) <type 'long'>
Üçüncü yöntem çevrilecek olan argümanla long
'u çağırmaktır. long
aynı int
ve float
't olduğu gibi tamsayıları, kayan noktalıları ve hatta rakamlardan oluşan karakter dizisini uzun tamsayıya çevirir:
>>> long(7) 7L >>> long(3.9) 3L >>> long('59') 59L
12.7 Harfleri saymak
7. bölümde, bir karakter dizisindeki harfleri sayan bir fonksiyon yazmıştık. Bu problemin daha genel bir biçimi karakter dizisindeki her bir harfin ne kadar yer aldığını gösteren bir sıklık grafiğinin (histogram) oluşturulmasıdır.
Bu şekildeki bir sıklık grafiği bir metin dosyasının sıkıştırılmasında yararlı olacaktır. Çünkü farklı harfler farklı sıklıklarla yer alacaktır, böylece sık karşılaşılan harfler için daha kısa kodlar, seyrek harfler için daha uzun kodlar kullanabiliriz.
Sıklık grafiği oluşturmak için sözlükler şık bir yol sunarlar:
>>> harf_sayilari = {} >>> for harf in "Mississippi": ... harf_sayilari[harf] = harf_sayilari.get(harf, 0) + 1 ... >>> harf_sayilari {'M': 1, 's': 4, 'p': 2, 'i': 4}
Boş bir sözlükle başlarız. Karakter dizisindeki her bir harf için, sözlükteki o anki sayıyı bulur (eğer yoksa sıfırdır), o sayıyı arttırırız. Sonda, sözlüğümüzde harflerin anahtar, değerlerin de harf sayıları olduğu durumu elde ederiz.
Sıklık grafiğini alfabetik sıraya göre görüntülemek daha çekici olabilir. Bunu items
ve sort
metotlarıyla yapabiliriz:
>>> harfler = harf_sayilari.items() >>> harfler.sort() >>> print harfler [('M', 1), ('i', 4), ('p', 2), ('s', 4)]
12.8 Örnek çalışma: Robotlar
Oyun
Bu örnek çalışmada klasik konsol oyunlarından robotlar oyununun bir sürümünü yazacağız.
Robotlar sıralı hamleli, kahraman olarak sizin aptal ancak acımasız robotlara karşı hayatta kalmaya çalıştığınız bir oyun. Her robot her hareket ettiğinizde (her hamlede) size sadece bir kare yaklaşabilir. Eğer sizi yakalarlarsa, ölürsünüz, çarpışırlarsa arkalarında bir robot çöplüğü bırakarak onlar ölür. Diğer robotlar bu çöplüğe çarptığında ölürler.
Temel strateji kendinizi robotlar birbirleriyle veya çöplüklerle çarpışacak şekilde konumlandırmaktır. Oyunu daha oynanabilir kılmak için size ayrıca başka bir konuma ışınlanma yeteneği verilmiştir -- 3 kere güvenli ışınlanma, diğerleri rastgele ışınlanma.
Dünyayı, oyuncuyu ve ana döngüyü ayarlama
Oyuncuyu ekrana yerleştiren ve klavye ile hareket ettiren fonksiyonları içerecek bir şekilde programa başlayalım:
# # robots.py # from gasp import * SCREEN_WIDTH = 640 SCREEN_HEIGHT = 480 GRID_WIDTH = SCREEN_WIDTH/10 - 1 GRID_HEIGHT = SCREEN_HEIGHT/10 - 1 def place_player(): x = random.randint(0, GRID_WIDTH) y = random.randint(0, GRID_HEIGHT) return {'shape': Circle((10*x+5, 10*y+5), 5, filled=True), 'x': x, 'y': y} def move_player(player): update_when('key_pressed') if key_pressed('escape'): return True elif key_pressed('4'): if player['x'] > 0: player['x'] -= 1 elif key_pressed('7'): if player['x'] > 0: player['x'] -= 1 if player['y'] < GRID_HEIGHT: player['y'] += 1 elif key_pressed('8'): if player['y'] < GRID_HEIGHT: player['y'] += 1 elif key_pressed('9'): if player['x'] < GRID_WIDTH: player['x'] += 1 if player['y'] < GRID_HEIGHT: player['y'] += 1 elif key_pressed('6'): if player['x'] < GRID_WIDTH: player['x'] += 1 elif key_pressed('3'): if player['x'] < GRID_WIDTH: player['x'] += 1 if player['y'] > 0: player['y'] -= 1 elif key_pressed('2'): if player['y'] > 0: player['y'] -= 1 elif key_pressed('1'): if player['x'] > 0: player['x'] -= 1 if player['y'] > 0: player['y'] -= 1 else: return False move_to(player['shape'], (10*player['x']+5, 10*player['y']+5)) return False def play_game(): begin_graphics(SCREEN_WIDTH, SCREEN_HEIGHT) player = place_player() finished = False while not finished: finished = move_player(player) end_graphics() if __name__ == '__main__': play_game()
Kullanıcıyla etkileşim içeren bunun gibi programlar etkileşimi olaylar (event) (tuş basma, fare tıklama, vb.) aracılığıyla gerçekleştirir. Bunlara olay güdümlü programlar adı verilir.
Ana döngü olay döngüsü bu kademede kolaydır:
while not finished: finished = move_player(player)
Olay kotarma işlemi move_player
fonksiyonu içinde yapılmaktadır. update_when('key_pressed')
bir tuşa basılana kadar bekler, tuşa basıldıktan sonra sonraki cümleye geçer. Çoklu dallandırma cümlesi daha sonra oyunla ilgili tüm tuşları kotarır.
ESC tuşuna basmak move_player
'in True
döndürmesine, böylece not finished
'i yanlışlayıp ana döngüden ve oyundan çıkılmasına neden olur. 4, 7, 8, 9, 6, 3, 2, ve 1 tuşlarının hepsi oyuncunun uygun yönde hareket etmesini sağlar, eğer oyuncu pencere kenarına gelmemişse.
Robot ekleme
Şimdi oyuncu her hareket ettiğinde oyuncuya doğru hareket eden bir robot ekleyelim.
Aşağıdaki place_robot
fonksiyonunu place_player
ve move_player
arasına yerleştirin:
def place_robot(): x = random.randint(0, GRID_WIDTH) y = random.randint(0, GRID_HEIGHT) return {'shape': Box((10*x, 10*y), 10, 10), 'x': x, 'y': y}
move_robot
fonksiyonunu hemen move_player
'in ardına ekleyin:
def move_robot(robot, player): if robot['x'] < player['x']: robot['x'] += 1 elif robot['x'] > player['x']: robot['x'] -= 1 if robot['y'] < player['y']: robot['y'] += 1 elif robot['y'] > player['y']: robot['y'] -= 1 move_to(robot['shape'], (10*robot['x'], 10*robot['y']))
Robot ve oyuncuyu bu fonksiyona geçirmemiz gerekir, böylece konumları karşılaştırılıp robot oyuncuya doğru yönlendirilebilir.
Şimdi robot = place_robot()
satırını programın ana gövdesinde player = place_player()
'ın ardına yerleştirelim, ve move_robot(robot, player)
satırını da ana döngünün içerisinde finished = move_player(player)
satırının ardına ekleyelim.
Şimdi oyuncuya acımasızca ilerleyen bir robota sahibiz, ama oyuncuyu yakaladığında onunla birlikte aynı yöne ilerler. Yapmamız gereken oyuncu yakalanır yakalanmaz oyunu bitirmektir. Aşağıdaki fonksiyon yakalanmanın olup olmadığına karar verir:
def collided(robot, player): return player['x'] == robot['x'] and player['y'] == robot['y']
Bu fonksiyonu move_player
fonksiyonunun hemen altına yerleştirelim. Şimdi play_game
fonksiyonunu çarpışmaları denetlemek üzere değiştirelim:
def play_game(): begin_graphics(SCREEN_WIDTH, SCREEN_HEIGHT) player = place_player() robot = place_robot() defeated = False while not defeated: quit = move_player(player) if quit: break move_robot(robot, player) defeated = collided(robot, player) if defeated: remove_from_screen(player['shape']) remove_from_screen(robot['shape']) Text("Yakalandın!", (240, 240), size=32) sleep(3) end_graphics()
Yeni bir değişken yarattık, defeated
, bu değişken collided
fonksiyonun sonucudur. Ana döngü defeated
yanlış olana kadar devam edecektir. ESC tuşuna basmak hala programı sonlandırmaktadır, quit
sınaması yapıp doğru ise ana döngüden çıktığımız için. Son olarak ana döngüden hemen sonra defeated
kontrolü yapıp eğer doğruysa uygun bir mesajı ekranda görüntülüyoruz.
Daha fazla robot ekleme
Şimdi yapabileceğimi bir çok şey var:
- oyuncunun bir robotun üstünde çıkmaması için
güvenli
yerleştirilmesi. - oyuncuya ışınlanma yeteneğinin verilmesi, böylece takipten başka bir konuma kaçabilir.
- daha fazla robot eklenmesi.
Bu görevlerden herhangi biri ilk önce yapılabilir olsa da, biz sonuncuyla daha fazla robot eklemeyle ilgileneceğiz.
İkinci bir robot eklemek için sadece place_robot
çağrımını yapan robot2
isminde yeni bir değişken yaratabiliriz. Ancak daha fazla robot eklemek istedikçe ve robotların sayısı arttıkça bu yöntem gereksiz bir yük getirecektir. Daha şık bir yöntem tüm robotları bir listede tutmaktır:
def place_robots(numbots): robots = [] for i in range(numbots): robots.append(place_robot()) return robots
Şimdi place_robot
fonksiyonunu play_game
içinde çağırmak yerine, place_robots
fonksiyonunu çağırırız, bu bize tüm robotları içeren bir liste döndürecektir:
robots = place_robots(2)
Birden fazla robotun eklendiği durumda her bir robotun hareketiyle ayrıca ilgilenmemiz gerekecek. Bunu tek bir robot için yapmıştık, şimdi yapmamız gereken tek şey tüm listedeki robotları dolaşmak ve hareket ettirmek:
def move_robots(robots, player): for robot in robots: move_robot(robot, player)
move_robots
fonksiyonunu move_robot
fonksiyonundan sonraya ekliyoruz, ve play_game
fonksiyonunu move_robot
fonksiyonu yerine move_robots
fonksiyonunu çağıracak şekilde düzeltiyoruz.
Şimdi de her bir robotun oyuncuyla çarpışıp çarpışmadığını incelememiz gerekiyor:
def check_collisions(robots, player): for robot in robots: if collided(robot, player): return True return False
Son olarak play_game
içerisindeki defeated
'i ayarlayan satırı collided
yerine check_collisions
fonksiyonunu çağıracak şekilde düzeltiriz.
12.9 Sözlük
- sözlük:
- Anahtar-değer çiftlerinde oluşan, anahtarları değerlere eşleyen veri tipidir. Anahtarlar herhangi bir değiştirilemez tip olabilir, değerler ise herhangi bir tip olabilir.
- eşleme tipi:
- Anahtar ve ilişkili değerlerin kolleksiyonlarından oluşan veri tipidir. Python'un yerleşik tep eşleme tipi sözlüktür. Sözlükler ilişkili dizi soyut veri tipini gerçekleştirmektedir.
- anahtar:
- Sözlükte bir değere eşlenen veri öğesidir. Anahtarlar sözlükteki değerlere bakmak, erişmek için kullanılmaktadır.
- anahtar-değer çifti:
- Sözlükteki öğelerin bir çiftidir. Sözlükteki değerlere anahtarlarla erişilir.
- ipucu:
- Tekrar hesaplamayı önlemek üzere önceden hesaplanmış değerlerin geçici saklanmasıdır.
- olay:
- Klavye tuşuna basma, fare tıklaması veya bir başka programdan mesaj gibi sinyallerdir.
- olay güdümlü program:
- Olayları algılayan, işleyen ve kotaran programlardır. Olayları işlemek için kotarıcılar (handler) vardır.
- olay döngüsü:
- Olayları bekleyen ve onları işleyen programlama yapısı
- taşma:
- Nümerik biçimde gösterilemeyecek kadar büyük nümerik sonuçtur.
12.10 Alıştırmalar
-
Komut satırından karakter dizisi okuyan ve alfabedeki harflerin tablosunu girilen karakter dizisindeki bulunma sayısıyla birlikte listeleyen bir program yazınız. Küçük-büyük farkı yok sayılmalıdır. Programın örnek bir çalıştırması aşağıdaki olmalıdır:
$ python harf_sayilari.py "ThiS is String with Upper and lower case Letters." a 2 c 1 d 1 e 5 g 1 h 2 i 4 l 2 n 2 o 1 p 2 r 4 s 5 t 5 u 1 w 2 $
-
Aşağıdaki yorumlayıcı oturumlarındaki sorgular için sonuçları üretin:
>>> d = {'apples': 15, 'bananas': 35, 'grapes': 12} >>> d['banana']
>>> d['oranges'] = 20 >>> len(d)
>>> d.has_key('grapes')
>>> d['pears']
>>> d.get('pears', 0)
>>> fruits = d.keys() >>> fruits.sort() >>> print fruits
>>> del d['apples'] >>> d.has_key('apples')
def add_fruit(inventory, fruit, quantity=0): """ Adds quantity of fruit to inventory. >>> new_inventory = {} >>> add_fruit(new_inventory, 'strawberries', 10) >>> new_inventory.has_key('strawberries') True >>> new_inventory['strawberries'] 10 >>> add_fruit(new_inventory, 'strawberries', 25) >>> new_inventory['strawberries'] """
Çözümünüz doctestleri geçmelidir. alice_words.py
isminde bir program yazın, programınız alice_in_wonderland.txt dosyasındaki tüm kelimelerin alfabetik listesini her bir kelimenin kaç kere yer aldığıyla birliktealice_words.txt
adındaki metin dosyasına yazsın. Çıktınızın ilk 10 satırı aşağıdakine benzeyecektir:Kelime Adet ======================= a 631 a-piece 1 abide 1 able 1 about 94 above 3 absence 1 absurd 2
alice
kelimesi kitapta kaç kere yer almaktadır?Alice in Wonderland (Alice Harikalar Diyarında)
'ki en uzun kelime hangisidir? Kelime kaç karakter içermektedir??- DÜnyayı, oyuncuyu, ve ana döngüyü ayarlamak kısmındaki kodu
robots.py
dosyasına yazın ve çalıştırın. Oyuncuyu ekranda nümerik tuş takımı yardımıyla hareket ettirebiliyor olmanız gerekiyor, ayrıca ESC tuşuyla program çıkabilirsiniz. - Dizüstü bilgisayarlar genellikle ayrı bir nümerik tuş takımı içermeyen ve masaüstü bilgisayarlara göre daha küçük bir klavye içerirler. Robotlar programını '4', '7', '8', '9', '6', '3', '2', ve '1' yerine 'a','q','w','e','d','c','x', ve 'z' tuşlarını kullanacak şekilde değiştirin. Böylece tipik bir dizüstü klavyede de çalışacaktır.
- Add all the necessary code from the Adding a robot section in the places indicated. Make sure the program works and that you now have a robot following around your player.
- Daha fazla robot ekleme kısmındaki ilgili yerlere eklenecek tüm kodları ekleyin. Programınız çalıştığından ve oyuncunuzu iki robotun izlediğinden emin olun.
robots = place_robots(2)
'deki argümanı 2'den 4'e değiştirin ve 4 robotun oluşturulduğunu ve istendiği gibi çalıştığını doğrulayın.