A’dan Z’ye Pandas Tutoriali (Başlangıç ve Orta Seviye)

Pandas, Python programlama dili için yüksek performanslı, kullanımı kolay veri yapıları ve veri analiz araçları sağlayan açık kaynaklı bir kütüphanedir. ‘.csv’ ve ‘.txt’ dosyalarını açmak ve içerisinde bulunan verileri okuyarak istenen sonuca kolayca ulaşmak için kullanılmaktadır. Yani Pandas sayesinde bir excel dosyasını açarak içerisinde bulunan bir sütunu veya satırı seçip işlem yapabiliriz. Numpy kütüphanesinde yapılan verilerin şekillendirilmesi işlemi daha detaylı bir biçimde kullanılabilmektedir.

Pandas ile aklınıza gelebilecek pek çok işlemi başarıyla ve birkaç satır kodla yapabilirsiniz. Örneğin, İlk karadeliğin görüntüsünün verisi pandas ile düzenlenmiştir. Ayrıca Pandas hız konusunda da optimize edilmiştir ve çok hızlı bir şekilde işlem yapabilmektedir. Başlamadan önce Numpy hakkındaki şu yazıyı okumanızı şiddetle tavsiye ederim. Çünkü bu iki konu birbirinden ayrılması imkansız olan konulardır ve bu ders için temel hazırlamasına yardımcı olacaktır.

Öncelikle ‘Seriler’ konusunu işleyeceğiz. Ardından’ DataFrame oluşturma ve işlevleri’ne değineceğiz. Çeşitli ‘Filtreleme işlemleri’nden sonra ‘DataFramelerin multi index olarak tanımlanması’ konusunu görüp, ‘Bozuk veya Hatalı veri durumunda neler yapabiliriz?’ sorusuna yanıt arayacağız. ‘GroupBy Sorguları’ ile belli bir değere göre sınıflamayı öğreneceğiz ve son olarak ‘Concatenate merge ve join fonksiyonları’ konusuna değindikten sonra yazımızı sonlandıracağız. Aşağıdaki kodla Pandas kütüphanemizi ‘import’ edelim ve Pandas’a ilk adımımızı atalım.

import pandas as pd

Ve şimdi ‘Pandas Serileri’ne geçmeye hazırız.

Pandas Serileri

Seriler Numpy dizileri baz alınarak oluşturuldukları için onlara çok benzerler. Seri, etiketli verilerden oluşan tek boyutlu bir veri yapısıdır. Etiket değerlerine ise indeks denir. Verinin kendisi sayılar, dizeler veya başka Python objelerinden oluşabilir. Serileri oluşturmak için ise listeler, sıralı diziler ya da sözlükler kullanılabilir. Pandas Serileri aşağıdaki değişkenleri alırlar.

Burada da ‘Bir seri nasıl oluşturulur?’ sorusunun cevabını görüyorsunuz.

Input:
Label_list = ['I','am','Learning','Data','Science']
Data_List = [1,2,3,4,5]
Pd_Series1 = pd.Series(Data_List,Label_list)

Ama illaki bu yolla ya da bu uzunlukta olmak zorunda değildir, Şu şekilde de olabilir.

Input:
data = np.array(['a','b','c','d'])
Series = pd.Series(data,[100,101,102,103])
Output:
100    a
101    b
102    c
103    d
dtype: object

Şimdi 3 tane Seri oluşturalım ve bu seriler üzerinde bir takım işlemler uygulayalım.

Input:
DataDict = {'Michael_s exam result': 35, 'Olivia_s exam result': 85}
A = pd.Series(DataDict)
Output:
Michael_s exam result    35
Olivia_s exam result     85
dtype: int64
Input:
DataDict2 = {'Michael_s exam result': 44}
B = pd.Series(DataDict2)
Output:
Michael_s exam result    44
dtype: int64
Input:
DataDict3 = {'Darth_Vader_s exam result' :99}
C = pd.Series(DataDict3)
Output:
Darth_Vader_s exam result    99
dtype: int64

Görmüş olduğunuz gibi 3 adet seri oluşturduk. Sıra kullanabileceğimiz bazı durumlarda.

Input:
A + B
Output:
Michael_s exam result    79.0
Olivia_s exam result      NaN
dtype: float64

Bu durumlardan ilki: iki seri arasında dört işlem ve daha fazlası yapılabilir. Ancak dikkat etmeniz gereken bir husus var: ‘A’ değerinin içinde ‘Michael’ ve ‘Olivia’ kişilerinin sınav sonuçları varken, ‘B’ değerinde sadece ‘Michael’ kişisinin sınav sonucu var. İki değeri işleme soktuğumuzda sadece eşleşen değerler işleme tabii olur. Eşleşmeyen değer olursa (Bu örnekte ‘Olivia’ kişisi), o değer ‘NaN’ olarak görünecektir.

‘Peki NaN nedir?’ diye soruyorsanız, ‘Not a number’ın kısaltılmış halidir ve bu veri tipinin sayı olmadığını ifade eder.

Input:
DataDict4 = C.append(A)
Output:
Darth_Vader_s exam result    99
Michael_s exam result        35
Olivia_s exam result         85
dtype: int64

Yukarıda görüldüğü gibi ‘DataDict4’ diye bir değer oluşturup, ‘C’ değerine ‘A’ değerini ekledik ve üç kişinin de sınav sonuçlarını görebildik. Gerçi ‘Darth Vader’ bu kadar yüksek not almışsa muhtemelen ‘Gücün karanlık tarafı’ ile ilgili bir sınavdır. :)

Input:
A['Michael_s exam result']
Output:
35
Input:
C['Darth_Vader_s exam result']
Output:
99

Yukarıda bulunan kodu hemen açıklayayım. ‘A’ değerinde ‘Michael’ ve ‘Olivia’ kişilerinin sınav sonuçları vardı. Diyelim ki biz ‘Michael’ kişisinin sınav sonucunu öğrenmek istiyoruz. Bu durumda ilk kodu yazmamız gerekir. Aynısı ‘Darth Vader’ karakteri için de geçerlidir. Bu illaki sayısal bir değer olmak zorunda değildir (int veya float). ‘String’ yani kelimelerden oluşan bir veri de olabilirdi.

‘Series’ konusu aslında bu kadar kısa ve öz şimdi ‘DataFrame’ konusuna geçelim.

Pandas DataFrame

DataFrameler, Türkçesiyle ‘Veri Çerçeveleri’ Pandas kütüphanesinde asıl olayın döndüğü kısımdır ve pek çok işlemi bu kısımda yapacağız. Burada sütunlar ‘Column’ ya da ‘Feature’ olarak satırlar ise ‘row’ ya da ‘ indeks’ olarak adlandırılır.

Öncelikle kendimize bir veri oluşturmalıyız.

from numpy.random import randn
Input:
df = pd.DataFrame(data = randn(5,5), index = ['A','B','C','D','E'], columns = ['Columns1','Columns2','Columns3','Columns4','Columns5'])
Output:

Eğer ‘randn’ fonksiyonunu ilk defa görüyorsanız ‘Numpy’ hakkında olan yazıyı okuyabilirsiniz.

Çalıştığınız veride size gerekli olan sütunları şu yöntemle alabilirsiniz.

Input:
df['Columns1']
Output:
A   -0.405682
B    0.083131
C    0.809041
D    1.103567
E    0.026578
Name: Columns1, dtype: float64

Üstelik sadece 1 sütun değil aynı yöntemle birden fazla sütunu da alabiliyorsunuz.

Input:
df[['Columns1','Columns5']]
Output:

Yeni bir sütun ekleme işlemini ise şöyle yapıyoruz.

Input:
df['Columns6'] = pd.Series(randn(5),['A','B','C','D','E'])
Output:

Bununla da sınırlı değil, istediğiniz sütuna ya da satıra istediğiniz işlemi de uygulayabilirsiniz.

Input:
df['Columns7'] = (df['Columns6'] + df['Columns4'] - df['Columns1'] ) / df['Columns2'] * df['Columns3']
Output:

Örneğin, yukarıda ‘Column7’ değerini oluşturup onu çeşitli sütunların işlemler sonucu oluşturduğu bir değere eşitledik ve böyle bir tablo oluştu.

Peki ‘Column’ ekleriz de çıkaramaz mıyız ?

Input:
df.drop('Columns2', axis = 1, inplace = True)
Output:

‘Axis’ in ne olduğunu merak edenler için kendisinin ‘default’ değeri 0'dır ve ‘0’ satırları ‘1’ sütunlarını simgeler. Buradaki ‘inplace’ parametresi önemlidir, bu işlemin kalıcı olup olmadığını belirler ve ‘True’ dediğimiz zaman kalıcı olarak atama yapar.

Bir ‘Column’ değerini index başlığı olarak şöyle atayabiliyoruz.

df.set_index('Column ismi', inplace = True)

Aşğıdaki şekilde de ‘index’ ve ‘Column’ların isimlerini öğrenebiliyoruz.

Input:
df.index.names
Output:
FrozenList([None])
Input:
df.column.names
Output:
FrozenList([None])

Şimdi ise ‘loc’ ve ‘iloc’ durumunu işleyelim.

Input:
df.loc['C']
Output:
Columns1     0.236537
Columns3    -1.595101
Columns4     3.393466
Columns5     2.040532
Columns7   -13.011599
Name: C, dtype: float64

Bu kodu kullandığımızda, bize ‘C’ satırında ki ‘Column’ değerlerini vermektedir.

Input:
df.loc['A']
Output:
Columns1    0.868092
Columns3   -0.155522
Columns4   -0.475097
Columns5   -0.825116
Columns7   -1.175716
Name: A, dtype: float64
Input:
df.iloc[0]
Output:
Columns1    0.868092
Columns3   -0.155522
Columns4   -0.475097
Columns5   -0.825116
Columns7   -1.175716
Name: A, dtype: float64

Bu ikisi arasındaki bağlantıyı oturup bir 10 saniye düşünmenizi istiyorum. Şunu farkedeceksiniz ki ikisi de oldukça benzer şeyler.

‘iloc’ fonksiyonu, satırın indeksine göre ‘Column’ değerlerini çıkartır ve satırların indeksleri bildiğiniz gibi 0'dan başlayarak ilerliyor. ‘A’nın indeksi 0, ve ‘iloc’ fonksiyonuna ‘0’ verilmiş. Bu durumda bu iki fonksiyon aslında aynı şeyi temsil ediyor. ‘loc’ fonksiyonunda isim belirtmeniz gerekirken, ‘iloc’ da indeks belirtmeniz gerekiyor.

Bazen daha ileri gitmek gerekir, mesela aşağıdaki gibi.

Input:
df.loc['A','Columns5']
Output:
-0.8251161336118147

İstenilen veri özel bir veri ya da nokta atışı yapılması gereken bir veri ise bu kullanılır.

Input:
df.loc[['A','Columns5'] and ['B','Columns4']]
Output:

Eğer bu işlemleri ‘Kaggle’ ortamında yapıyorsanız yukarıdaki gibi bir şey çıkarsa endişelenmeyin. Bu birbhata değildir kodunuz sorunsuz çalışacaktır.

Anlaşıldığı üzere yukarıdaki ‘or , ‘and’ gibi ifadelerde kullanılabilmektedir.

Input:
df.loc[['A','D'],['Columns4','Columns2']]
Output:

Yukarıda da görüldüğü gibi birden fazla sütun ve satırı çağırıp bakabiliyoruz. Buradaki konumuz bitti, sırada ‘DataFrame Filtreleme işlemleri’ var.

DataFrame Filtreleme İşlemleri

Adından da anlaşıldığı gibi, elimizde bulunan verinin belli aralıklardaki değeri bulmak ya da almak istediğimizde kullanmaktayız. Dilerseniz Verimizi hatırlayalım ve basit işlemlerle başlayalım.

Input:
df
Output:

Ve basit işlemlere geçelim.

Input:
df > 0.2
Output:

Input:
booleanDF = df > 0
Output:

‘Boolean’ı şöyle açıklayabiliriz. İstenilen değer (burada ‘0’dan büyük olma şartı ile), koşulu sağlıyorsa ‘True’ değilse ‘False’ değerini döndürür.

Input:
df[booleanDF]
Output:

Burada ise ‘NaN’ değerleri üstteki Boolean değerindeki ‘False’ değerlerini temsil etmekte.

Input:
df[df > 0.5]
Output:

Burada ise ‘df’ içinde ‘0.5’ten büyük olanları gösterir. ‘False’ olanlar yine ‘NaN’ olarak gösteriliyor. Bunu daha ileride daha iyi örneklerle açıklayacağız.

Input:
df['Columns1'] > 0
Output:

Yukarıda ise belli bir ‘Column’ değerinin filtrelemesini görüyorsunuz. Aşağıda ise bunu her ‘Column’ değerine uygulanışını görüyorsunuz. Bazılarında sonuç farklı. Bazılarında 4 satır varken bazılarında 2 satır var, sizce neden olabilir ?

Input:
df[df['Columns3']> 0]
Output:

Input:
df[df['Columns4']> 0]
Output:

Input:
df[df['Columns5']> 0]
Output:

Input:
df[df['Columns1']> 0]
Output:

Kısaca özetlemek gerekirse, ‘True’ olan değerler gösterilir. Örneğin, ‘Column4’te 4 satır bulunmakta demek ki 5. satır ‘True’ değerinde.

Input:
df[(df['Columns1']> 0) & (df['Columns3']> 0)]
Output:

Input:
df[(df['Columns1']> 0) | (df['Columns5']> 1)]
Output:

Yukarıda çeşitli filtreleme alıştırmalarını görüyorsunuz. Önceden bahsettiğimiz kurallara tabiidirler. ‘&’ işareti ‘and’ anlamında ve ‘|’işareti ‘or’ anlamındadır. Bu işaretler yerine ‘and’ ya da ‘or’ kullanır iseniz hata alırsınız. ‘&’ işareti ‘SHIFT’ ve ‘6’ tuşları ile ‘|’ işareti ise ‘ALT GR’ ve ‘-’ ile yapılmaktadır.

Input:
df
Output:

Input:
df['Columns6'] = ['NewValue1','NewValue2','NewValue3','NewValue4','NewValue5']
Output:

Verimizi güncellerken 2. fotoğrafta anlaşıldığı üzere verilen değer ‘String’ olsa bile direk atandığıdır.

Input:
df.set_index('Columns6' , inplace = True)
Output:

Input:
df.index.names
Output:

Input:
df.columns.names
Output:

Yukarıda ilk satırda kalıcı bir şekilde index ismini ‘Column6’ olarak atadık. 2. satırda index başlığını sorguladık. Son kodda ise aynı mantıkla sütun ismini sorguluyor ve biz atamadığımız için ‘None’ çıkıyor.

DataFramelerin Multi İndex Olarak Tanımlanması

Multi index, adından da anlaşılacağı gibi index sayısının çok olduğu durumlarda kullanılır ve temel olarak gruplanır.

Input:
OuterIndex = ['Group1','Group1','Group1','Group2','Group2','Group2','Group3','Group3','Group3']
InnerIndex = ['Index1','Index2','Index3','Index1','Index2','Index3','Index1','Index2','Index3']
list(zip(OuterIndex,InnerIndex))
Output:

Input:
hierarchy = list(zip(OuterIndex,InnerIndex))
hierarchy = pd.MultiIndex.from_tuples(hierarchy)
Output:

Input:
df = pd.DataFrame(randn(9,3),hierarchy,columns = ['Column1','Colum2','Column3'])
Output:

1.görselde 2 adet index oluşturup ‘zip’ fonksiyonu ile birleştirdik. Bunu yaparken liste kullandık ama siz ‘Tuple’ ve ‘Dict’ de kullanabilirsiniz. 2. görselde bunu ‘hierarchy’e eşitledik. Sonra ise ‘pd.MultiIndex.from_tuples()’ özelliği ile Multi index’i oluşturduk. En son görselde ise ‘rand()’ fonksiyonu ile rastgele değerler atayıp sütun bilgilerini verdik. Ve görüldüğü üzere ‘Group’ ‘Index’ ‘Column’ değerlerine sahip Multi index DataFrame elde ettik.

Input:
df['Column1']
Output:

Input:
df.loc['Group1']
Output:

Input:
df.loc[['Group1','Group2']]
Output:

Yukarıda gördüğünüz gibi belli bir kısmı bu şekilde çağırabilirsiniz.

Input:
df.loc['Group1']
Output:

Input:
df.loc[['Group1','Group2']]
Output:

Input:
df.loc['Group1'].loc['Index1']
Output:

‘Group’, ‘Column’ ve ‘Index’ gibi değerleri bu şekilde çağrılabilir ve birden fazla ve farklı türden de çağırma yapabilirsiniz.

Input:
df.loc['Group1'].loc['Index1']['Column1']
Output:

Nokta atışı veriler için yukarıdakine benzer kodarla işinizi halledebilirsiniz.

Input:
df.index.names = ['Groups','Indexes']
Output:

Index isimlerini öğrenme aynı şekilde sütunları da sorgulayabilirsiniz.

Input:
df.xs('Group1') # df.xs('Group1') = df.loc['Group1']
Output:

‘xs’ fonksiyonuna biraz değinelim. Yukarıda bildiğimiz bir koda eşit olduğunu görüyorsunuz. ‘xs’ fonksiyonu ‘loc’, ‘iloc’ gibi işlevsel fonksiyonları yerine getirebilir ve bize güzel avantajlar da sağlar.

Input:
df.xs('Group1').xs('Index1')
Output:

Input:
df.xs('Group1').xs('Index1').xs('Column1')
Output:

İlk fotoğrafta önce ‘Group’ sonra ‘Index’ değeri veriliyor. Çünkü ‘xs’ fonksiyonu ‘Group’, ‘Index’ sırasıyla çalışmaktadır. Bu durum 2. fotoğrafı da açıklamaktadır.

‘Peki her seferinde böyle uğraşacak mıyız? Nerede bunun avantajı?’ diyorsanız aşağıdaki durumlara bakabilirsiniz.

Input:
df.xs('Index1', level = 'Indexes')
Output:

Input:
df.xs('Index1', level = 'Indexes')['Column1']
Output:

Bozuk Ve Kayıp Verilerle Ugraşabilmek

Bazen almış olduğumuz veriler tam, düzgün çıkmayabiliyor. Bazen veriler kayıp olup, bizi amacımıza uzaklaştırabiliyor. Bu durumlarda ne yapılması gerektiğini anlatacağız. Ama önce kayıp bir veri oluşturalım.

Input:
arr = np.array([[10,20,np.nan],[3,np.nan,np.nan],[13,np.nan,4]])
Output:

‘np.nan’ kodu anlaşıldığı üzere veride ‘Not a Number’ oluşturuyor.

Input:
df = pd.DataFrame(arr, index = ['Index1','Index2','Index3'],columns = ['Column1','Column2','Column3'] )
Output:

Ve bu veri ile bu şekilde bir DataFrame’ye eşitledik.

Buradan sonra göreceğiniz adımları kesin kullanın demiyorum. Ama incelediğiniz veri, istenilen veya aranan veriye göre adımlar değişebilir. Bazen veride kayıp olan yerlere ortalama, 0 ,1 , standart sapma gibi parametreler konulabiliyor. Bazense direkt siliniyor. Bu tamamen sizin ne yapmak istediğinize kalmıştır.

Input:
df = pd.DataFrame(arr, index = ['Index1','Index2','Index3'],columns = ['Column1','Column2','Column3'] )
Output:

Input:
df.dropna()
Output:

Mesela yukarıda ki kod, ‘Index’ satırında en az bir ‘NaN’ var ise siler.

Input:
df.dropna(axis = 1)
Output:

‘Axis’ parametresini ‘Column’a göre ayarladığımızda ise içinde hiç ‘NaN’ değeri olmayan ‘Column1’i bize döndürür ve diğerlerini siler. Aynı zamanda ‘inplace’ değerini ‘True’ vermediğiniz müddetçe kalıcı değildir.

Input:
df.dropna(thresh = 2)
Output:

Sizce ‘thresh’ parametresi nedir? Hemen söyleyelim. ‘En az iki düzgün veri var ise silme’ anlamına gelmektedir. Elbette ki bu sayıyı siz belirliyorsunuz.

Input:
df.fillna(value = 0) # '' ile birlikte string değer de yazılabilir.
Output:

Bu kod içine aldığı ‘value’ değerini boş veriye atar. Örnekte, ‘0’ değeri verilmiş ve ‘NaN’ değerlerine atanmış. ‘String’ değer verilebildiği gibi oldukça da işlevseldir.

Verinin yapısının uygun olduğunu ve bizim aradığımız verinin ortalamadan bağımsız olduğunu varsayalım ve ‘NaN’ değerleri yerine ortalamayı atayalım.

Input:
df.sum()
Output:

Input:
df.sum().sum()
Output:

İlk kodun, görüldüğü üzere her ‘Column’ değerinin toplamını, Sonraki kodun ise hepsinin toplamını verdiğini farketmişsinizdir.

Input:
df.fillna(value = (df.sum().sum())/ 5)
Output:

Bu mantığı ‘value’ değerine atarsak ve 5'e bölersek (ortalama almak için), ‘NaN’ değerleri yerine ‘10’ atayacaktır.

Aynı mantık ile standart sapma, varyans gibi değerleri de yapabiliriz. Ama bunu daha önceki yazımızda açıklamıştık ve ordaki kodu buraya rahatlıkla uygulayabilirsiniz.

Bazen daha basit sorgularda oldukça işlevseldir.

Input:
df.size
Output:

Kaç adet veri olduğunu sorgular.

Input:
df.isnull()
Output:

‘True’ olan değerler ‘NaN’ı temsil etmektedir.

Input:
df.isnull().sum()
Output:

‘Hangi ‘Column’da kaç adet ‘NaN’ var?’ sorunun cevabı bu koddur.

Input:
df.isnull().sum().sum()
Output:

Bu kod ise toplam kaç adet ‘NaN’ değeri olduğunu verir.

Eğer biz toplam kaçar adet veri olduğunu biliyorsak ve yukarıdaki kod ile de kaç adet ‘NaN’ değerini olduğunu da biliyorsak, Her ‘Column’da kaç adet düzgün veri olduğunu da bulabiliriz.

Input:
df.size - df.isnull().sum()
Output:

İşte bu kodda bahsettiğimiz düzgün veri miktarının ‘Column’lara göre dağılımıdır.

GroupBy Operasyonları

GroupBy Operasyonları, Sql tablolarındankiyle tamamen aynı. Sql bilmiyor iseniz bile rahat olun. Zor bir konu değil ancak önemli bir konu. İstenilen durumu gruplar gösterir.

Input:
data = {'Job': ['Data Mining','CEO','Lawyer','Lawyer','Data Mining','CEO'],'Labouring': ['Immanuel','Jeff','Olivia','Maria','Walker','Obi-Wan'], 'Salary': [4500,30000,6000,5250,5000,35000]}
Output:

Verimizi oluşturduktan sonra, DataFrame’e atıyoruz.

Input:
df = pd.DataFrame(data)
Output:

Input:
SalaryGroupBy = df.groupby('Salary')
Output:

Ve ‘Salary’ özelliğine göre gruplamış olduk.

Input:
SalaryGroupBy.sum()
Output:

Input:
SalaryGroupBy.min()
Output:

Input:
SalaryGroupBy.max()
Output:

Gördüğünüz gibi hangi fonksiyonu kullanırsanız kullanın, tablo halinde yansıtacaktır.

Input:
df.groupby('Salary').sum()# Bu şekilde de işlem kısaltılabilir.
Output:

Son iki fotoğraftaki işlemi yukarıdaki kod tek başına yapmaktadır.

Input:
df.groupby('Job').sum().loc['CEO']
Output:

‘CEO’ların maaşların toplamı.

Input:
df.groupby('Job').count()
Output:

Input:
df.groupby('Job').min()
Output:

Numpy yazısındaki fonksiyonlar burada da kullanılabilmektedir.

Input:
df.groupby('Job').min()['Salary']
Output:

Input:
df.groupby('Job').min()['Salary']['Lawyer']
Output:

İlkinde ‘Salary’e göre gruplayıp en düşük maaşları bastırdık. Sonrakinde ise en düşük maaşlı avukatın, maaşını bastırdık.

Input:
df.groupby('Job').mean()['Salary']['CEO']
Output:

Burada ise, mesleğe göre sıralayıp Ceo’ların ortalama maaşını bulduk. GroupBy Operasyonları, görüldüğü gibi zor bir konu değil. Oldukça kısa ve öz bir konu.

Concatenate Merge Ve Join Fonksiyonları

İlk olarak Concatenate ile başlayalım. Temel olarak birleştirme işlemini bu fonksiyon ile yapmaktayız. Aynı listelerdeki ‘zip’ fonksiyonu gibidir.

Input:
data = {'A': ['A1','A2','A3','A4'],'B': ['B1','B2','B3','B4'],'C': ['C1','C2','C3','C4']}
data1 = {'A': ['A5','A6','A7','A8'],'B': ['B5','B6','B7','B8'],'C': ['C5','C6','C7','C8']}
df1 = pd.DataFrame(data, index = [1,2,3,4])
df2 = pd.DataFrame(data1, index = [5,6,7,8])
df1
Output:

Input:
df2
Output:

İki tane veri seti oluşturalım. Ve aşağıdaki gibi birleştirelim.

Input:
pd.concat([df1,df2])
Output:

Şöyle de birleştirilebilirdi.

Input:
pd.concat([df1,df2], axis = 1)
Output:

Burada olmayan veriler elbetteki ‘NaN’ olarak atanıyor. Bu işlem yalnızca 2 değil daha fazla sayıda olan durumlarda da kullanılabilir.

Join, ile devam edelim. ‘Join’ fonkiyonları adı üstünde birbirlerine katılma işlemleri olarak düşünülebilir. Ve lisedeki ‘kümeler’ konusu olarak da düşünülebilir. Öyleyse iki veri oluşturup bu işlemleri yapmaya başlayalım.

Input:
data = {'A': ['A1','A2','A3','A4'],'B': ['B1','B2','B3','B4'],'C': ['C1','C2','C3','C4']}
data1 = {'A': ['A5','A6','A7','A8'],'B': ['B5','B6','B7','B8'],'C': ['C5','C6','C7','C8']}
df1 = pd.DataFrame(data, index = [1,2,3,4])
df2 = pd.DataFrame(data1, index = [5,6,7,8])
df1
Output:

Input:
df2 = pd.DataFrame(data2, columns = ['id', 'Feature1', 'Feature2'])
Output:

‘Left Join’ ile başlayalım.

Left Join, Sql’deki ‘Left Join’ ile birebir aynıdır. İşlevi ise yukarıda verilmiştir. Siz burada ‘df1'i table1 olarak, ‘df2’yi table2 olarak düşünmelisiniz.

Input:
df1.join(df2)
Output

Tam tersini yaparsak sizce ne olur ?

Input:
df2.join.(df1)
Output:

Right Join, ile de aynı mantık yürütülebilir. İşlevi ve kodu aşağıda verilmiştir.

Input:
df1.join(df2, how = 'right')
Output:

Sırada ‘inner’ ve ‘outer’ join fonksiyonları var.

‘Full Outer Joın’ yazdığına bakmayın. O Sql’deki ismi, burada sadece ‘outer’ olarak geçiyor ve aşağıda ikisinin de örnekleri var.

Input:
df1.join(df2, how ='outer')
Output:

Input:
df1.join(df2, how = 'inner')
Output:

Input:
df1.join(df2, sort = 'True')
Output:

Input:
df1.join(df2, sort = 'False')
Output:

Input:
frames = [df1,df2]
df_keys = pd.concat(frames, keys=['x', 'y'])
df_keys
Output:

Siyah olan yazı hata değil bir uyarı mesajıdır. Çok dikkate almayınız. Bazen sürümle alakalı uyarı verebiliyor.

Aşağıda ise ‘Join’in tüm parametreleri yer almakta ve öğrendiklerimize kıyasla daha az kullanılmaktadırlar. İsterseniz araştırabilirsiniz.

Merge işlemi, join işlemi ile oldukça benzemekle beraber bazı farklı özelliklere sahiptir. Aşağıda daha detaylı anlatacağız.

Yukarıda Merge işleminin tüm parametrelerini görmektesiniz. Ama pek çoğunu kullanmayacağız.

Input:
dataset1 = {'A':['A1','A2','A3'], 'B': ['B1','B2','B3'], 'Key': ['K1','K2','K3']}
dataset2 = {'X':['X1','X2','X3','X4'], 'Y': ['Y1','Y2','Y3','Y4'], 'Key': ['K1','K2','K3','K4']}
df1 = pd.DataFrame(dataset1,index = [1,2,3])
df2 = pd.DataFrame(dataset2,index = [1,2,3,4])
df1
Output:

Input:
df2
Output:

Verimizi de oluşturduğumuza göre başlayabiliriz.

Input:
pd.merge(df1,df2, on = 'Key')
Output:

Ve ilk parametremizle tanıştık bile. ‘On’ parametresine anahtarı yazmanız gerekmektedir. Anahtar sizin verinizde önemli yeri olmalıdır ki gerçek manada ‘anahtar’ olabilsin.

Input:
pd.merge(df1,df2, on = 'Key', how = 'left')
Output:

‘How’ parametresine zaten Join konusundan alışığız. Orada gördüğünüz ‘inner’, ‘outer’ , ‘right’ değerleri burada da geçerli.

Input:
pd.merge(df1,df2, on = 'Key', how = 'right')
Output:

Input:
pd.merge(df1,df2, on = 'Key', how = 'outer')
Output:

Input:
pd.merge(df1,df2, on = 'Key', how = 'inner')
Output:

Input:
pd.merge(df1,df2, on = 'Key', how = 'right',right_index=True)
Output:

Input:
pd.merge(df1,df2, left_index=True, right_index=True, how='outer')
Output:

Input:
pd.merge(df1,df2, left_index=True, right_index=True, how='inner')
Output:

‘left_index’ ve ‘right_index’ parametreleri ise fotoğraflardan anlaşılacak kadar basit. Diğer parametreler hemen hemen kullanılmaz ama isterseniz Pandasın kendi sitesinden araştırabilirsiniz.

DataFrame Operasyonları Ve Pivot Table

Burada küçük ama işlevsel fonksiyonları gördükten sonra ‘Pivot Table’ konusunu işleyeceğiz. Önce verimizi oluşturalım ve başlayalım.

Input:
data = {'Column1': [1,2,3,4,5,6], 'Column2': [1000,1000,2000,3000,3000,1000],'Column3': ['Mace Windu','Darth Vader','Palpatine','Kylo Ren','Rey','Obi-Wan']}
df = pd.DataFrame(data)
df
Output:

Ve küçük ama işlevsel fonksiyonlarımıza gelelim.

Input:
df.head()
Output:

Input:
df.head(n = 2) # df.head(2) = df.head(n = 2)
Output:

‘head()’ ilk 5 değeri göstermekte ama içine aldığı değer kadar da gösterebilir. Örnekte 2 verilmiş. Aynı şekilde ‘tail()’de son 5 değeri gösterir. O da ‘head()’ gibi değer alabilir.

Input:
df.describe()
Output:

Input:
df.info
Output:

‘describe()’ bazı istatistiksel bilgiler verirken, ‘corr()’ korelasyon bilgisini verir. Ama bu data ile uyumlu olmadığı için aşağıda açıklayacağız. ‘info()’ ise adından da anlaşılacağı gibi temel bilgiler veriyor. Bu fonksiyonlar veriye ilk bakışınız olacağı için kullanmanızı tavsiye ederiz.

Input:
df['Column2'].unique()
Output:

Input:
df['Column2'].nunique()
Output:

‘unique()’ verilen verinin kaç adet ‘eşşiz’ verisi olduğunu bize verir. Aşağıdaki kod ise kaç adet ‘eşşiz’ değer olduğunu veriyor.

Input:
df['Column2'].value_counts()
Output:

‘value_counts()’ ise hangi değerden kaç adet olduğunu veren bir fonksiyon.

Input:
df[df['Column1'] >= 2]
Output:

Input:
df[(df['Column1'] >= 2) & (df['Column2'] == 300) ]
Output:

Anlaşıldığı üzere ‘DataFrame Filtreleme’ işlemlerini de burada kullanabiliyoruz.

Input:
def square(x): 
    return x ** 2
square(2)
Output:

Burada bir Fonksiyon oluşturup içine aldığı değerin karesini vermesini sağladık.

Input:
df['Column2'].apply(square)
Output:

Bu fonksiyonu ‘apply()’ ile verimize attığımızda bize karelerini verdi.

Bu özel durumu projelerinizde kullanabilirsiniz. Örneğin, aracın motor kısmının verisini inceliyorsunuz ve ekibiniz sizden motora ait bir bulgu istedi. Onlardan gerekli olan matematiksel formülü alıp aynı bu örnekteki gibi kullanıp rahatlıkla işinizi yapabilirsiniz.

Ama bunun daha kısa bir yolu var.

Input:
lambda x : x **2
Output:

Input:
df['Column2'].apply(lambda x : x **2 )
Output:

‘lambda’ genelde daha kısa olmasından ötürü daha çok tercih edilir .

# df['Column2'] = df['Column2'].apply(square) # Güncelleyebilmek için bunu kullanıyoruz. Ayrıca lambdayıda kullanabirdik.

Ama bu işlemleri yapınca veriniz otomatik olarak güncellenmiyor. Sizin güncellemeniz gerekiyor, onu da yukarıdaki gibi yapıyoruz.

Input:
df['Column3']
Output:

Input:
df['Column3'].apply(len) # String'in uzunluğunu alma
Output:

Input:
df.drop('Column3', axis = 1 )
Output:

Input:
df.index
Output:

Input:
df.index.names
Output:

Yukarıdaki fonksiyonların bazılarını daha önce işlemiştik. Muhtemelen tek anlatmadığım ‘df.index’ fonksiyonu. O da şöyle ‘0’dan başlamış ‘6’ya kadar ‘1’er ‘1’er ilerlemiş. Altındaki anlamı bu kadar basit. Şimdi ise ‘sort_values()’e geçelim.

Aşağıda aldığı parametreleri görüyorsunuz. ‘by’ neye göre alınacağını belirtirken, ‘ascending’ sıralamasını neye göre olacağını belirtir. Küçükten büyüğe ya da büyükten küçüğe olarak sıralayabilirsiniz. ‘Axis’ ve ‘İnplace’ parametrelerini zaten biliyorsunuz. ‘kind’ parametresi aşağıda yazan 3 adete göre verinizi düzenleyebilirsiniz. Çok kullanılmaz ama isterseniz araştırabilirsiniz. ‘na_postion’ ise ‘NaN’ değerlerinin pozisyonunu belirtmenizi sağlar.

Input:
df
Output:

Input:
df.sort_values(by=['Column1', 'Column3']) # Birden fazla değerde 'Sort' edilebilir.
Output:

Bu fonksiyon belli bir değere göre sıralamamızı sağlar. Biz burada ‘Column2’ye göre sıralamasını sağladık. Yukarı da ise ‘Column1’ ve ‘Column3’e sıraladık ki farkı görebilesiniz.

Input:
df.sort_values(by=['Column1', 'Column2'])
Output:

Input:
df.sort_values('Column2', ascending = True) # Küçükten Büyüğe
Output:

Input:
df.sort_values('Column2', ascending = False) # Büyükten küçüğe
Output:

Input:
df.sort_values('Column1', kind = 'heapsort')
Output:

Input:
df.sort_values('Column1', kind = 'mergesort')
Output:

Input:
df.sort_values('Column1', kind = 'quicksort')
Output:

Input:
df.sort_values('Column1', na_position = 'first')
Output:

Input:
df.sort_values('Column1', na_position = 'last')
Output:

Verimiz bazı parametreler için (kind ve na_position) için pek de uygun değil. Bazıları aynı sonucu verdi. Ama biz nasıl yapıldığını da göstermek istedik. Dediğimiz gibi çok kullanılmaz, isterseniz araştırabilirsiniz.

Gelelim ‘Pivot Table’ konusuna. Excel biliyorsanız korkacak bir şey yok. Çünkü tamamıyla aynı. Bilmiyorsanız da endişelenmeyin. Çünkü çok basit bir kullanımı var.

Input:
df = pd.DataFrame({'Month': ['January','February','March','January','February','March','January','February','March'],'State':['New York','New York','New York','Texas','Texas','Texas','Washington','Washington','Washington'],
'moisture': [20,25,65,34,56,85,21,56,79]})
df
Output:

Başlamadan önce ‘corr()’dan bahsediceğimizi söylemiştik. Burada onu anlatalım(her ne kadar data uygun olmasa da). Önceden bahsettiğimiz gibi korelasyonu anlatmaktadır.

Input:
df.corr()
Output:

3 farklı şehirde, 3 farklı aydaki, 3 yüzdesel nem oranımız var diyelim.

Input:
df.pivot_table(index = 'Month', columns = 'State', values = 'moisture')
Output:

Input:
df.pivot_table(index = 'State', columns = 'Month', values = 'moisture')
Output:

Yukarıdaki gibi pivot table oluşturabilir. İşte bu kadar basit.

Veri Setini Okuma Yöntemleri

Bu konu aslında aşağıdaki ile açıklanabilir.

dataset = pd.read_csv('Dosya_Yolu\Data_Name.csv') # Pc'de IDE'nizde bu şekilde okuyabilirsiniz.
df=pd.read_csv("../input/Data_Name.csv") # Kaggle kernel yazmak için( ama güncelleme geldi bazen çalışmıyor)
dataset.to_csv('Data_Name') # Datayı tekrardan csv'ye dönüştürebilmek için
excelset = pd.read_excel('Excels_Name.xlsx') # Excel Dosyasını okumak için
excelset.to_excel('excelnewfile.xlsx') # Excel dosyasına çevirme
New = pd.read_html(' Datasetin urlsi.html') # İnternette ki bir veriyi okumak için

Normal de burada bitirecektim ama son zamanlarda oldukça güncel ve epey tutacağını düşündüğüm bir özelliği paylaşmak istiyorum. İsmi ‘Pandas_Profiling()’.

Öncelikle datamızı import etmemiz, internet ortamında değilsek (offonline isek) ‘path’ vermemiz gerekir.

Daha sonra yukarıda ki gibi işlemler yapılır sonra ise…

Yukarıda görüldüğü gibi pek çok özelliği içinde barındırmaktadır. Ayrıca Daha çok güncel bir konu olduğu için deneyimleyemedim ve bu fotoğrafları yabancı kaynaklardan almak zorunda kaldım.

Son Söz

Evet arkadaşlar buraya kadar geldiyseniz ve gerçekten hakkını verdiyseniz kendiniz için ‘İyi seviyede Pandas biliyorum’ diyebilirsiniz. Ama bununla yetinmemeli pek çok farklı kaynağı araştırmalı ve çalışmalısınız. Zamanı geldikçe yazı güncellenecektir. Daha detaylı halini ilerleyen zamanlarda Kaggle sayfamda paylaştım buradan ulaşabilirsiniz.

Yazımı okuduğunuz ve kıymetli zamanınızı ayırdığınız için müteşekkirim. Sağlıcakla kalın ve öğrenmeyi kesmeyin.

print(‘İyi Günler !’)