Python Veri Yapıları Eğitimi

Veri yapıları, verilerin verimli şekilde erişilip işlenebilmesi için düzenlenmesi ve depolanması yoludur. Veriler arasındaki ilişkiyi ve veriler üzerinde gerçekleştirilebilecek işlemleri tanımlarlar. Tanımlanmış birçok farklı veri yapısı vardır; bunlar, hem veri bilimcilerin hem de bilgisayar mühendislerinin, veri tanımı ve erişiminin ayrıntılarında kaybolmak yerine daha büyük problemleri çözmeye odaklanmasını kolaylaştırır.

Bu eğitimde, çeşitli Python veri yapılarını öğrenecek ve nasıl uygulandıklarını göreceksiniz:

• Soyut Veri Tipi ve Veri Yapıları
• İlkel Veri Yapıları
  • Tamsayılar (Integers)
  • Ondalık sayılar (Float)
  • Dizgiler (Strings)
  • Boolean
• İlkel Olmayan Veri Yapıları
  • Diziler (Arrays)
  • Listeler
  • Demetler (Tuples)
  • Sözlük (Dictionary)
  • Kümeler (Sets)
  • Dosyalar

Ücretsiz Intro to Python for Data Science kursumuzda, Python’u özellikle veri bilimi bağlamında kullanma hakkında daha fazla bilgi edinebilirsiniz. Kurs, Python’un temel kavramlarına giriş sunar. Bu sayede yöntemleri, fonksiyonları ve NumPy paketini keşfedeceksiniz.

Soyut Veri Tipi ve Veri Yapıları

Girişte okuduğunuz gibi, veri yapıları ayrıntılarda kaybolmak yerine daha büyük resme odaklanmanıza yardımcı olur. Buna veri soyutlama (data abstraction) denir.

Veri yapıları aslında Soyut Veri Tiplerinin (ADT) bir uygulamasıdır. Bu uygulama, bazı programlama yapıları ve temel veri tiplerinin bir koleksiyonunu kullanarak verinin fiziksel bir görünümünü gerektirir.

Genel olarak bilgisayar bilimlerinde veri yapıları iki kategoriye ayrılabilir: ilkel ve ilkel olmayan veri yapıları. İlkel olanlar veriyi temsil etmenin en basit biçimleriyken, ilkel olmayanlar daha gelişmiştir: özel amaçlar için daha karmaşık veri yapıları içinde ilkel veri yapılarını barındırırlar.

İlkel Veri Yapıları

Bunlar en ilkel veya temel veri yapılarıdır. Veri manipülasyonu için yapı taşlarıdır ve saf, basit veri değerlerini içerirler. Python’da dört ilkel değişken türü vardır:

• Tamsayılar
• Ondalık sayılar (Float)
• Dizgiler (Strings)
• Boolean

Sonraki bölümlerde bunlar hakkında daha fazlasını öğreneceksiniz!

Integers

Tamsayıları sayısal veriyi, daha spesifik olarak eksi sonsuzdan artı sonsuza kadar olan tam sayıları (ör. 4, 5 veya -1) temsil etmek için kullanabilirsiniz.

Float

"Float", ‘kayan noktalı sayı’ anlamına gelir. Genellikle ondalık basamakla biten rasyonel sayılar için kullanabilirsiniz; 1.11 veya 3.14 gibi.

Aşağıdaki DataCamp Light parçasına göz atın ve bazı tamsayı ve float işlemlerini deneyin!

Not Python’da, değişkenin ya da verinizin türünü açıkça belirtmek zorunda değilsiniz. Bunun nedeni, dinamik tipli bir dil olmasıdır. Dinamik tipli dillerde, bir nesnenin saklayabileceği veri türü değişkendir.

String

Dizgiler; harfler, kelimeler veya diğer karakterlerin koleksiyonlarıdır. Python’da tek veya çift tırnak içine alınmış bir karakter dizisiyle string oluşturabilirsiniz. Örneğin: 'cake', "cookie" vb.

Ayrıca iki veya daha fazla string üzerinde + işlemini uygulayarak bunları birleştirebilirsiniz; aşağıdaki örnekte olduğu gibi:

x = 'Cake'
y = 'Cookie'
x + ' & ' + y

'Cake & Cookie'

İşte stringlerle yapabileceğiniz diğer bazı temel işlemler; Örneğin, bir string’i belirli sayıda tekrarlamak için * kullanabilirsiniz:

# Repeat
x * 2

'CakeCake'

Ayrıca string dilimleme de yapabilirsiniz; bu, stringlerin parçalarını seçtiğiniz anlamına gelir:

# Range Slicing
z1 = x[2:]  

print(z1)

# Slicing
z2 = y[0] + y[1]

ke
Co

Not stringler alfa-sayısal karakterler de olabilir, ancak + işlemi yine string birleştirme için kullanılır.

x = '4'
y = '2'

x + y

'42'

Python, stringleri değiştirmek için birçok yerleşik yöntem veya yardımcı fonksiyon sunar. Bir alt dizgiyi değiştirmek, bir paragraftaki belirli kelimeleri büyük harfe çevirmek, bir dizgenin içinde başka bir dizgenin konumunu bulmak yaygın string işlemlerindendir. İşte bunlardan bazıları:

Dizgileri büyük harfe çevirin

str.capitalize('cookie')

'Cookie'

Bir dizgenin karakter olarak uzunluğunu alın. Boşlukların da nihai sonuca dahil edildiğini unutmayın:

str1 = "Cake 4 U"
str2 = "404"
len(str1)

8

Bir dizgenin yalnızca rakamlardan oluşup oluşmadığını kontrol edin

str1.isdigit()

False

str2.isdigit()

True

Dizgilerin bölümlerini diğer dizgilerle değiştirin

str1.replace('4 U', str2)

'Cake 404'

Diğer dizgiler içinde alt dizgiler bulun; Alt dizgenin bulunduğu en düşük dizin veya konumu döndürür:

str1 = 'cookie'
str2 = 'cook'
str1.find(str2)

0

Alt dizge

'cook'

stringin başında bulunur:

'cookie'

. Sonuç olarak, şu string içindeki konuma referans verirsiniz:

'cookie'

alt dizgeyi bulduğunuz yer. Bu durumda,

0

döndürülür; çünkü konumları 0’dan itibaren saymaya başlarsınız!

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

Benzer şekilde,

'cook'

alt dizgesi, şu string içinde 12. pozisyonda bulunur:

'I got you a cookie'

Unutmayın, saymaya 0’dan başlıyorsunuz ve boşluklar da pozisyonlara dahildir!

Python’daki string yöntemlerinin kapsamlı bir listesini burada bulabilirsiniz.

Boolean

Bu yerleşik veri türü True ve False değerlerini alabilir; bu da onları sıklıkla 1 ve 0 tamsayılarıyla birbirinin yerine kullanılabilir kılar. Boolean’lar, aşağıdaki örneklerde olduğu gibi koşullu ve karşılaştırma ifadelerinde kullanışlıdır:

x = 4
y = 2
x == y

False

x > y

True

x = 4
y = 2
z = (x==y) # Karşılaştırma ifadesi (False döner)
if z: # 'z' değişkeninin doğruluk/yanlışlık değerine koşul
    print("Cookie")
else: print("No Cookie")

No Cookie

Veri Tipi Dönüşümü

Bazen kendinizi başkasının koduyla çalışırken bulursunuz ve örneğin bir tamsayıyı floata veya tersine dönüştürmeniz gerekir. Ya da aslında ihtiyacınız float olduğu halde tamsayı kullandığınızı fark edebilirsiniz. Bu gibi durumlarda, değişkenlerin veri türünü dönüştürebilirsiniz!

Python’da bir nesnenin türünü kontrol etmek için aşağıdaki satırlarda olduğu gibi yerleşik type() fonksiyonunu kullanın:

i = 4.0
type(i)

float

Bir varlığın türünü bir veri türünden diğerine değiştirdiğinizde buna "tip dönüşümü" (typecasting) denir. İki tür veri dönüşümü olabilir: örtük (coercion olarak da adlandırılır) ve açık (casting olarak da adlandırılır).

Örtük veri tipi dönüşümü

Bu otomatik bir veri dönüşümüdür ve bunu derleyici sizin için halleder. Aşağıdaki örneklere bakın:

# A float
x = 4.0 

# An integer
y = 2 

# Divide `x` by `y`
z = x/y

# Check the type of `z`
type(z)

float

Yukarıdaki örnekte, float bölme işlemini gerçekleştirmek için y’nin veri türünü açıkça değiştirmeniz gerekmedi. Derleyici bunu sizin için örtük olarak yaptı.

Bu kadar kolay!

Açık veri tipi dönüşümü

Bu tür veri tipi dönüşümü kullanıcı tanımlıdır; yani belirli varlıkların veri türünü değiştirmesi için derleyiciyi açıkça bilgilendirmeniz gerekir. Bunu tam olarak anlamak için aşağıdaki kod parçasını ele alın:

x = 2
y = "The Godfather: Part "
fav_movie = y + x

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-51-b8fe90df9e0e> in <module>()
      1 x = 2
      2 y = "The Godfather: Part "
----> 3 fav_movie = y + x


TypeError: Can't convert 'int' object to str implicitly

Yukarıdaki örnek bir hata verdi; çünkü derleyici, karışık veri türleri nedeniyle birleştirme mi yoksa toplama mı yapmaya çalıştığınızı anlamıyor. Bir tamsayı ile bir string’i birlikte toplamaya çalışıyorsunuz.

Bariz bir uyumsuzluk var.

Bunu çözmek için önce int değerini bir string’e dönüştürmeli ve ardından birleştirme işlemini gerçekleştirmelisiniz.

Not bir veri türünü başka bir türe dönüştürmek her zaman mümkün olmayabilir. Burada kullanabileceğiniz bazı yerleşik veri dönüşüm fonksiyonları: int(), float() ve str().

x = 2
y = "The Godfather: Part "
fav_movie = (y) + str(x)
print(fav_movie)

The Godfather: Part 2

İlkel Olmayan Veri Yapıları

İlkel olmayan türler, veri yapıları ailesinin sofistike üyeleridir. Yalnızca bir değer saklamazlar; çeşitli biçimlerde bir değerler koleksiyonu saklarlar.

Geleneksel bilgisayar bilimi dünyasında, ilkel olmayan veri yapıları şunlara ayrılır:

• Diziler
• Listeler
• Dosyalar

Array

Öncelikle Python’da diziler, temel veri tiplerini derli toplu biçimde bir araya getirmenin bir yoludur; bir dizideki tüm girdiler aynı veri türünde olmalıdır. Ancak diziler, C++ veya Java gibi diğer programlama dillerinin aksine Python’da o kadar popüler değildir.

Genel olarak, Python’da insanlar dizilerden bahsettiğinde aslında listeleri kastederler. Ancak aralarında temel bir fark vardır; bunu birazdan göreceksiniz. Python için diziler, belirli bir tür listedeki öğeleri saklamanın daha verimli bir yolu olarak görülebilir. Bu tür listede ise öğeler aynı veri tipindedir.

Python’da diziler array modülü tarafından desteklenir ve bunları başlatıp kullanmaya başlamadan önce içe aktarılması gerekir. Bir dizide saklanan öğelerin veri türü kısıtlıdır. Veri türü dizi oluşturma sırasında belirtilir ve aşağıdaki örnekte gördüğünüz I gibi tek karakterli bir tür kodu kullanılarak ifade edilir:

import array as arr
a = arr.array("I",[3,6,9])
type(a)

array.array

Python Array dokümantasyonu sayfası, mevcut çeşitli tür kodları ve array modülünün sunduğu işlevler hakkında daha fazla bilgi sağlar.

List

Python’da listeler, heterojen öğe koleksiyonlarını depolamak için kullanılır. Bunlar değiştirilebilir (mutable) yapıdadır; yani kimliklerini değiştirmeden içeriklerini değiştirebilirsiniz. Listeleri, virgülle , ayrılmış öğeleri tutan köşeli parantezler [ ve ] ile tanıyabilirsiniz. Listeler Python’a yerleşiktir; ayrıca çağırmanız gerekmez.

x = [] # Empty list
type(x)

list

x1 = [1,2,3]
type(x1)

list

x2 = list([1,'apple',3])
type(x2)

list

print(x2[1])

apple

x2[1] = 'orange'
print(x2)

[1, 'orange', 3]

Not: Yukarıdaki x1 örneğinde gördüğünüz gibi listeler homojen öğeleri de tutabilir ve dolayısıyla bir dizinin depolama işlevini karşılar. Bu, bu koleksiyona özgü bazı işlemleri uygulamak istemediğiniz sürece sorun değildir.

Python, listeleri manipüle etmek ve onlarla çalışmak için birçok yöntem sunar. Bir listeye yeni öğeler eklemek, listeden bazı öğeleri kaldırmak, bir listeyi sıralamak veya ters çevirmek yaygın liste işlemleridir. Bunların bazılarını uygulamada görelim:

• append() ile list_num listesine 11 ekleyin. Varsayılan olarak bu sayı listenin sonuna eklenir.

list_num = [1,2,45,6,7,2,90,23,435]
list_char = ['c','o','o','k','i','e']

list_num.append(11) # Add 11 to the list, by default adds to the last position
print(list_num)

[1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• insert() kullanarak list_num listesinde 0 indeksine veya konumuna 11 ekleyin

list_num.insert(0, 11)
print(list_num)

[11, 1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• list_char içinden ilk 'o' oluşumunu remove() yardımıyla kaldırın

list_char.remove('o') 
print(list_char)

['c', 'o', 'k', 'i', 'e']

• list_char içinden -2 indeksindeki öğeyi kaldırın

list_char.pop(-2) # Removes the item at the specified position
print(list_char)

['c', 'o', 'k', 'e']

list_num.sort() # In-place sorting
print(list_num)

[1, 2, 2, 6, 7, 11, 11, 23, 45, 90, 435]

list.reverse(list_num)
print(list_num)

[435, 90, 45, 23, 11, 11, 7, 6, 2, 2, 1]

Python listeleri hakkında daha fazla bilgi edinmek isterseniz, En Yaygın 18 Python Liste Sorusu eğitimini kolayca inceleyebilirsiniz!

Diziler vs. Listeler

Artık Python’daki listeleri gördüğünüze göre, neden dizilere ihtiyaç duyduğunuzu merak ediyor olabilirsiniz. Sebep, üzerlerinde gerçekleştirilebilecek işlemler açısından temelde farklı olmalarıdır. Dizilerde, tüm öğeler üzerinde tek tek işlemleri kolayca gerçekleştirebilirsiniz; bu, listelerde her zaman böyle olmayabilir. İşte bir örnek:

array_char = array.array("u",["c","a","t","s"])
array_char.tostring()
print(array_char)

array('u', 'cats')

array_char’ın tostring() fonksiyonunu uygulayabildiniz; çünkü Python, bir dizideki tüm öğelerin aynı veri tipinde olduğunun farkındadır ve dolayısıyla işlem her öğede aynı şekilde davranır. Bu nedenle diziler, büyük bir homojen veri türü koleksiyonuyla uğraşırken çok kullanışlı olabilir. Python her bir öğenin veri türü ayrıntılarını tek tek tutmak zorunda olmadığından; bazı kullanımlarda diziler, listelere kıyasla daha hızlı olabilir ve daha az bellek kullanabilir.

Konumuz dizilerken NumPy dizisinden de bahsetmeye değer. NumPy dizileri, çok boyutlu dizilerle çalışmak için veri bilimi dünyasında yoğun şekilde kullanılır. Genel olarak array modülünden ve Python listelerinden daha verimlidirler. NumPy dizisinde eleman okuma-yazma daha hızlıdır ve eleman bazında toplama gibi "vektörleştirilmiş" işlemleri desteklerler. Ayrıca NumPy dizileri, büyük seyrek veri kümeleriyle verimli çalışır. Daha fazla bilgi için DataCamp’in Python Numpy Array Eğitimine göz atın.

İşte NumPy Array ile başlamanız için biraz kod:

import numpy as np

arr_a = np.array([3, 6, 9])
arr_b = arr_a/3 # Performing vectorized (element-wise) operations 
print(arr_b)

[ 1.  2.  3.]

arr_ones = np.ones(4)
print(arr_ones)

[ 1.  1.  1.  1.]

multi_arr_ones = np.ones((3,4)) # Creating 2D array with 3 rows and 4 columns
print(multi_arr_ones)

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

Geleneksel olarak, liste veri yapısı daha sonra doğrusal ve doğrusal olmayan veri yapıları olarak kategorize edilebilir. Stacks ve Queues “doğrusal veri yapıları” olarak adlandırılırken, Graphs ve Trees “doğrusal olmayan veri yapılarıdır”. Bu yapılar ve kavramları nispeten karmaşık olabilir ancak gerçek dünya modellerine benzemeleri nedeniyle yaygın olarak kullanılır. Bu eğitimde bu konulara kısa bir bakış atabilirsiniz.

Not: Doğrusal bir veri yapısında, veri öğeleri sıralı veya başka bir deyişle çizgisel olarak düzenlenir. Veri öğeleri art arda seri olarak dolaşılır ve doğrusal bir veri yapısındaki tüm veri öğeleri tek bir çalıştırmada dolaşılabilir. Oysa doğrusal olmayan veri yapılarında veri öğeleri sıralı olarak düzenlenmez. Bu, öğelerin, aralarındaki özel ilişkiyi yansıtmak için birden fazla öğeye bağlı olabileceği anlamına gelir. Doğrusal olmayan bir veri yapısındaki tüm veri öğeleri tek bir çalıştırmada dolaşılamayabilir.

Stacks

Yığın (stack), Son Giren İlk Çıkar (LIFO) kavramına göre nesnelerin eklendiği ve çıkarıldığı bir kaptır. Bir akşam yemeği davetinde tabak yığını olduğunu düşünün; tabaklar her zaman yığının üstünden eklenir veya çıkarılır. Bilgisayar biliminde bu kavram, ifadelerin değerlendirilmesi ve sözdizimi ayrıştırma, zamanlama algoritmaları/rutinleri vb. için kullanılır.

Yığınlar Python’da listeler kullanılarak uygulanabilir. Bir yığına öğe eklemenize itme (push) işlemi, bir öğeyi kaldırmanıza veya silmenize ise çekme (pop) işlemi denir. Not Python’da yığınlarla çalışırken pop() metodunun zaten elinizin altında olduğunu unutmayın:

# Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack = [1,2,3,4,5] 
stack.append(6) # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 (Top)
print(stack)

[1, 2, 3, 4, 5, 6]

stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 (Top)
print(stack)

[1, 2, 3, 4]

Queue

Kuyruk (queue), İlk Giren İlk Çıkar (FIFO) ilkesine göre nesnelerin eklendiği ve çıkarıldığı bir kaptır. Gerçek dünyada mükemmel bir kuyruk örneği, insanların geliş sırasına göre ilgilenildiği ve dolayısıyla önce gelenin önce ayrıldığı bir gişe sırasıdır. Kuyrukların birçok farklı türü olabilir.

Listeler bir kuyruğu uygulamak için verimli değildir; çünkü bir listenin sonundan append() ve pop() hızlı değildir ve bellek taşıma maliyeti doğurur. Ayrıca, listenin sonuna ekleme ve başından silme, öğe pozisyonlarında kaydırma gerektirdiğinden o kadar hızlı değildir.

Graphs

Matematik ve bilgisayar biliminde bir grafik, her biri birbiriyle bağlantılı olabilen ya da olmayabilen düğümlerden (tepe noktaları) oluşan ağlardır. İki düğümü bağlayan çizgi veya yol, kenar (edge) olarak adlandırılır. Kenarın belirli bir akış yönü varsa, bu yönlü bir grafiktir ve yönlü kenara yay (arc) denir. Yön belirtilmemişse, grafiğe yönsüz grafik denir.

Bunların hepsi kulağa oldukça teorik gelebilir ve daha derine indikçe oldukça karmaşıklaşabilir. Ancak grafikler, özellikle veri biliminde önemli bir kavramdır ve gerçek yaşam problemlerini modellemek için sıklıkla kullanılır. Sosyal ağlar, kimya ve biyolojide moleküler çalışmalar, haritalar ve öneri sistemleri, graf ve graf kuramı prensiplerine dayanır.

Başlamanıza yardımcı olmak için burada bir Python Sözlüğü kullanılarak yapılmış basit bir grafik uygulaması bulacaksınız:

graph = { "a" : ["c", "d"],
          "b" : ["d", "e"],
          "c" : ["a", "e"],
          "d" : ["a", "b"],
          "e" : ["b", "c"]
        }

def define_edges(graph):
    edges = []
    for vertices in graph:
        for neighbour in graph[vertices]:
            edges.append((vertices, neighbour))
    return edges

print(define_edges(graph))

[('a', 'c'), ('a', 'd'), ('b', 'd'), ('b', 'e'), ('c', 'a'), ('c', 'e'), ('e', 'b'), ('e', 'c'), ('d', 'a'), ('d', 'b')]

Grafiklerle, iki düğüm arasında bir yol olup olmadığını bulmak, iki düğüm arasındaki en kısa yolu bulmak, grafikte döngüleri belirlemek gibi havalı şeyler yapabilirsiniz.

Ünlü “gezgin satıcı problemi”, aslında her düğümü tam olarak bir kez ziyaret eden ve başlangıç noktasına dönen en kısa rotayı bulmakla ilgilidir. Bazen bir grafiğin düğümlerine veya yaylarına ağırlıklar veya maliyetler atanır; bunu yürüme zorluğu atamak gibi düşünebilirsiniz ve en ucuz ya da en kolay yolu bulmakla ilgilenirsiniz.

Trees

Gerçek dünyada bir ağaç, kökleri toprakta olan ve yaprakları ile meyveyi taşıyan dalları açıkta olan bir canlıdır. Ağacın dalları bir ölçüde düzenli bir şekilde yayılır. Bilgisayar biliminde ağaçlar, bazen verilerin nasıl organize edildiğini tanımlamak için kullanılır; tek fark, kökün üstte olması, dallar ve yaprakların altta yer alması ve ağacın gerçek ağaca kıyasla ters çizilmesidir.

Biraz daha gösterim eklemek gerekirse, kök her zaman ağacın tepesindedir. Ağaç benzetmesine bağlı kalarak, onu takip eden diğer düğümlere dallar denir ve her dalın son düğümü yaprak olarak adlandırılır. Her dalı kendi içinde daha küçük bir ağaç olarak hayal edebilirsiniz. Kök genellikle ebeveyn olarak adlandırılır ve aşağıda atıfta bulunduğu düğümler çocuklarıdır. Aynı ebeveyne sahip düğümlere kardeşler denir. Neden buna soy ağacı da dendiğini görüyor musunuz?

Ağaçlar, gerçek dünya senaryolarını tanımlamaya yardımcı olur ve oyun dünyasından XML ayrıştırıcılarının tasarımına kadar her yerde kullanılır; PDF tasarım ilkesi de ağaçlara dayanır. Veri biliminde, ‘Karar Ağacı tabanlı Öğrenme’ aslında geniş bir araştırma alanı oluşturur. Bagging, boosting gibi çok sayıda ünlü yöntem, kestirimci bir model üretmek için ağaç modelini kullanır. Satranç gibi oyunlar, tüm olası hamlelerle devasa bir ağaç oluşturur; analiz eder ve sezgisel yöntemler uygulayarak en uygun hamleyi seçer.

Bu eğitimde şimdiye kadar gördüğünüz çeşitli veri yapılarını kullanıp birleştirerek bir ağaç yapısı uygulayabilirsiniz. Ancak sadelik adına, bu konu başka bir yazıda ele alınacaktır.

class Tree:
    def __init__(self, info, left=None, right=None):
        self.info = info
        self.left  = left
        self.right = right

    def __str__(self):
        return (str(self.info) + ', Left child: ' + str(self.left) + ', Right child: ' + str(self.right))

tree = Tree(1, Tree(2, 2.1, 2.2), Tree(3, 3.1))
print(tree)

1, Left child: 2, Left child: 2.1, Right child: 2.2, Right child: 3, Left child: 3.1, Right child: None

Dizileri öğrendiniz ve liste veri yapısını da gördünüz. Ancak Python, birçok farklı veri toplama mekanizması sağlar ve bunlar geleneksel bilgisayar bilimi veri yapısı konularına her zaman dahil edilmese de özellikle Python programlama dili açısından bilinmeye değerdir:

• Demetler (Tuples)
• Sözlük
• Kümeler

Tuples

Demetler (tuples) bir başka standart sıralı veri tipidir. Demetlerle listeler arasındaki fark, demetlerin değiştirilemez (immutable) olmasıdır; yani bir kez tanımlandıktan sonra içindeki değerleri silemez, ekleyemez veya düzenleyemezsiniz. Bu, kontrolü bir başkasına devretmek isteyip, verilerinizi koleksiyonda manipüle etmelerini istemediğiniz; sadece görmelerini veya verinin bir kopyası üzerinde ayrı işlemler yapmalarını istediğiniz durumlarda yararlı olabilir.

Demetler nasıl uygulanır bakalım:

x_tuple = 1,2,3,4,5
y_tuple = ('c','a','k','e')
x_tuple[0]

1

y_tuple[3]
x_tuple[0] = 0 # Cannot change values inside a tuple

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-74-b5d6da8c1297> in <module>()
      1 y_tuple[3]
----> 2 x_tuple[0] = 0 # Cannot change values inside a tuple


TypeError: 'tuple' object does not support item assignment

Dictionary

Bir telefon rehberine benzer bir şeyi uygulamak istiyorsanız, tam olarak ihtiyacınız olan şey sözlüklerdir. Daha önce gördüğünüz veri yapılarının hiçbiri bir telefon rehberi için uygun değildir.

İşte burada bir sözlük (dictionary) işe yarar. Sözlükler anahtar-değer çiftlerinden oluşur. key öğeyi tanımlamak için kullanılır ve value ise adından da anlaşılacağı gibi öğenin değerini tutar.

x_dict = {'Edward':1, 'Jorge':2, 'Prem':3, 'Joe':4}
del x_dict['Joe']
x_dict

{'Edward': 1, 'Jorge': 2, 'Prem': 3}

x_dict['Edward'] # Prints the value stored with the key 'Edward'.

1

Sözlükler üzerinde birçok diğer yerleşik işlevi uygulayabilirsiniz:

len(x_dict)

3

x_dict.keys()

dict_keys(['Prem', 'Edward', 'Jorge'])

x_dict.values()

dict_values([3, 1, 2])

Bu kod, anahtar-değer çiftlerini depolamak ve bunlara erişmek için bir Python sözlüğü kullanmanın bir örneğini gösterir.

Önce kod, x_dict argümanıyla len() fonksiyonunu çağırır. Bu, sözlükteki anahtar-değer çiftlerinin sayısını döndürür; bu da 3’tür.

Sonra kod, x_dict üzerinde keys() yöntemini çağırır. Bu, sözlükteki anahtarları içeren bir görünüm nesnesi döndürür. Bu durumda anahtarlar çıktıdaki gibi 'Prem', 'Edward' ve 'Jorge'dir.

Ardından kod, x_dict üzerinde values() yöntemini çağırır. Bu, sözlükteki değerleri içeren bir görünüm nesnesi döndürür. Bu durumda değerler, çıktıdaki gibi sırasıyla 3, 1 ve 2’dir.

Sets

Kümeler, farklı (benzersiz) nesnelerin koleksiyonudur. Veri kümesinde yalnızca benzersiz değerler tutan listeler oluşturmak için kullanışlıdır. Sırasız bir koleksiyondur ancak değiştirilebilir; bu, çok büyük bir veri kümesinde gezinirken oldukça yardımcı olur.

x_set = set('CAKE&COKE')
y_set = set('COOKIE')

print(x_set)

{'A', '&', 'O', 'E', 'C', 'K'}

print(y_set) # Single unique 'o'

{'I', 'O', 'E', 'C', 'K'}

print(x - y) # All the elements in x_set but not in y_set

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-3-31abf5d98454> in <module>()
----> 1 print(x - y) # All the elements in x_set but not in y_set


NameError: name 'x' is not defined

print(x_set|y_set) # Unique elements in x_set or y_set or both

{'C', '&', 'E', 'A', 'O', 'K', 'I'}

print(x_set & y_set) # Elements in both x_set and y_set

{'O', 'E', 'K', 'C'}

Kod, iki küme oluşturur: x_set ve y_set. Her küme, bir karakter dizgesi argüman olarak set() fonksiyonuna verilerek oluşturulur. Bu durumda x_set, 'CAKE&COKE' dizgesinden; y_set ise 'COOKIE' dizgesinden oluşturulur.

Ardından kod, print() fonksiyonunu kullanarak her kümeyi yazdırır. İlk print() ifadesi, 'CAKE&COKE' dizgesindeki benzersiz karakterleri içeren x_set’i yazdırır. Çıktı, x_set’in 'A', '&', 'O', 'E', 'C' ve 'K' karakterlerini içerdiğini gösterir. Benzer şekilde, ikinci print() ifadesi, 'COOKIE' dizgesindeki benzersiz karakterleri içeren y_set’i yazdırır. Çıktı, y_set’in 'I', 'O', 'E', 'C' ve 'K' karakterlerini içerdiğini gösterir.

Üçüncü print() ifadesi, y_set’te olmayan x_set’teki tüm öğelerin kümesini yazdırmaya çalışır. Ancak bu satır, x değişkeni tanımlanmadığı için bir NameError ile sonuçlanır. Muhtemelen bu satır print(x_set - y_set) şeklinde olmalıydı.

Dördüncü print() ifadesi, x_set veya y_set ya da her ikisindeki benzersiz öğelerin kümesini yazdırır. Çıktı, ortaya çıkan kümenin hem x_set hem de y_set’ten tüm benzersiz karakterleri içerdiğini gösterir.

Son olarak beşinci print() ifadesi, hem x_set hem de y_set içinde bulunan öğelerin kümesini yazdırır. Çıktı, bu kümenin 'O', 'E', 'K' ve 'C' karakterlerini içerdiğini gösterir.

Files

Dosyalar, geleneksel olarak veri yapılarına dahildir. Ve büyük veri, veri bilimi endüstrisinde yaygın olsa da, önceden depolanmış bilgiyi saklayıp geri getirme kabiliyeti olmayan bir programlama dili pek işe yaramaz. Yine de veritabanları genelindeki dosyalarda duran tüm verilerden yararlanmanız gerekir ve bunu nasıl yapacağınızı öğreneceksiniz.

Python’da dosya okuma ve yazma sözdizimi diğer programlama dillerine benzer ancak ele alması çok daha kolaydır. İşte Python kullanarak dosyalarla çalışmanıza yardımcı olacak bazı temel fonksiyonlar:

• Sisteminizdeki dosyaları açmak için open(); dosya adı, açılacak dosyanın adıdır;

• Tüm dosyaları okumak için read();

• Her seferinde bir satır okumak için readline();

• Bir dizgeyi dosyaya yazmak ve yazılan karakter sayısını döndürmek için write(); ve

• Dosyayı kapatmak için close().

# File modes (2nd argument): 'r'(read), 'w'(write), 'a'(appending), 'r+'(both reading and writing)
f = open('file_name', 'w')

# Reads entire file
f.read() 

# Reads one line at a time
f.readline() 

# Writes the string to the file, returning the number of char written
f.write('Add this line.') 

f.close()

open() fonksiyonundaki ikinci argüman, dosya kipidir. Okumak (r), yazmak (w), eklemek (a) veya hem okumak hem yazmak (r+) istediğinizi belirtmenize olanak tanır.

Python’da dosya işlemleri hakkında daha fazla bilgi edinmek için mutlaka bu sayfaya göz atın.

Sonuç

Bu eğitimin sonuna ulaştığınız için tebrikler! Bu, veri bilimi dünyasını fethetme hayallerinize bir konu daha yaklaştığınız anlamına geliyor.

İlginizi çekerse, iki parçalı Python Data Science Toolbox kursumuz, fonksiyonlar, yineleyiciler, listeler vb. konularına daha derinlemesine iner.