<jupyter_start><jupyter_text>**Pandas Serisi Oluşturmak** Pandas içerisinde yer alan veri tipleri değerleri, indeksleri ile beraber tutar.<jupyter_code>import pandas as pd
pd.Series([10,88,3,4,5]) #pandas serisi olusturmak.
 seri = pd.Series([10,88,3,4,5])
type(seri)
seri.axes #Serinin index bilgisine ulasiriz.
seri.dtype
seri.size #eleman sayisi
seri.ndim #boyutu
seri.values #vektor formunda sadece degerlere ulasiriz.
seri.head() #ilk 5 eleman
seri.head(3) #ilk 3 eleman
seri.tail(3) #son 3 eleman<jupyter_output><empty_output><jupyter_text>**Index İsimlendirmesi**<jupyter_code>pd.Series([23,24,25,26,27], index = [2,4,6,8,10])
seri = pd.Series([23,24,25,26,27], index = ["a","b","c","d","e"])
seri
seri["a"] #elemana erisme
seri["a":"c"] #serilerde slice islemi<jupyter_output><empty_output><jupyter_text>**Sözlük üzerinden seri oluşturmak**<jupyter_code>sozluk={"reg":10, "log":11, "cart":12}
seri = pd.Series(sozluk)
seri<jupyter_output><empty_output><jupyter_text>**İki Seriyi Birleştirerek Seri Oluşturma**<jupyter_code>pd.concat([seri, seri])<jupyter_output><empty_output><jupyter_text>**Eleman İşlemleri**<jupyter_code>import numpy as np
a = np.array([15,233,34,52,64])
seri = pd.Series(a) #NumPy Array'i uzerinden seri olusturalim
seri
seri[0] #0 indexli eleman
seri[0:3] #3'e kadar olan elemanlar
seri = pd.Series([133,244,355,467,234], index = ["reg","log","cart","pcv","rf"])
seri
seri.index #sadece indexler
seri.keys #seri'nin key'lerini gosterir
list(seri.items()) #key degerine karsilik gelen value'lari bir araya getirerek list olusturur.
seri.values #seri'nin sadece degerlerini gosterir<jupyter_output><empty_output><jupyter_text>**Eleman Sorgulama**<jupyter_code>"reg" in seri
"a" in seri
seri["reg"]<jupyter_output><empty_output><jupyter_text>**Fancy Eleman**<jupyter_code>seri[["rf","reg"]] #fancy ile eleman secme<jupyter_output><empty_output><jupyter_text>**Eleman Değiştirme**<jupyter_code>seri["reg"] = 111
seri #atama yontemi ile tekrardan eleman atayabiliriz.<jupyter_output><empty_output><jupyter_text>**Pandas DataFrame Oluşturma** Pandas DataFrame yapısal bir veri tipidir.<jupyter_code>import pandas as pd
l = [5,12,37,62,14] #list olusturduk
l<jupyter_output><empty_output><jupyter_text>pd.DataFrame(l, columns = ["degisken_ismi"]) DataFrame olusturma<jupyter_code>import numpy as np
m = np.arange(1,10).reshape(3,3)
m #3x3'luk bir matris
pd.DataFrame(m, columns=["var1","var2","var3"]) #2 boyutlu DataFrame<jupyter_output><empty_output><jupyter_text>**Yapay zeka ve Veri Biliminde en çok kullanacağımız veri tipi DataFrame'dir.** **DataFrame İsimlendirme**<jupyter_code>df = pd.DataFrame(m, columns=["var1","var2","var3"])
df.head(2)
df.columns = ("col1","col2","col3") #Sutunlari yeniden isimlendirme
df<jupyter_output><empty_output><jupyter_text>**DataFrame Özellikleri**<jupyter_code>type(df)
df.axes #Satir ve sutun bilgisi
df.shape #boyut bilgisi
df.ndim #boyut sayisi
df.size #eleman sayisi
df.values #DataFrame tipindeki veri yapisinin icersinden
          #Degerleri array tipinde aliyor.
type(df.values)
df.tail(1) #sondan 1. index<jupyter_output><empty_output><jupyter_text>Diğer veri tiplerinde veri oluşturmak için çeşitli formatlar kullandık.Örneğin; NumPy array'i üzerinden oluşturduk list üzerinden oluşturduk ve bunabenzer farklı formatlardan oluşturduk. Bu işlemler DataFrame için de geçerlidir.<jupyter_code>a = np.array([1,2,3,4,5])
pd.DataFrame(a, columns = ["deg1"]) #numpy array'i ile df olusturduk.<jupyter_output><empty_output><jupyter_text>**DataFrame Eleman İşlemleri**<jupyter_code>import numpy as np
s1 = np.random.randint(10, size=5)
s2 = np.random.randint(10, size=5)
s3 = np.random.randint(10, size=5)
sozluk={"var1":s1,"var2":s2,"var3":s3} #array'lerden sozluk
sozluk
import pandas as pd
df = pd.DataFrame(sozluk) #sozluk'den df
df
df[0:2] #0'dan 2'ye kadar
df.index
df.index = ["a","b","c","d","e"]
df
df.index
df["a":"c"]<jupyter_output><empty_output><jupyter_text>**<NAME>**<jupyter_code>df.drop("a", axis=0) #0 ekseninden "a" indexli satiri sil.
df #sildi ancak kaydetmedi.
df.drop("a", axis=0, inplace=True) #inplace argumani kalici olsun mu? anlamındadir.
df #kalici olarak silindi.<jupyter_output><empty_output><jupyter_text>**Fancy**<jupyter_code>l = ["c","e"]
df.drop(l, axis=0) #c ve e silindi<jupyter_output><empty_output><jupyter_text>**Degiskenler icin**<jupyter_code>df
"var1" in df
l = ["var1","var4","var2"]
for i in l:
    print(i in df)<jupyter_output>True
False
True<jupyter_text>Bir değişken oluşturmak isteyelim fakat bu değişkenimizi DataFrame içinde var olan değişkenlerden yapmak istediğimizi düşünelim.<jupyter_code>df
df["var4"] = df["var1"] / df["var2"]
df<jupyter_output><empty_output><jupyter_text>**Değişken Silme**<jupyter_code>df
df.drop("var4", axis=1, inplace=True)
df
l = ["var1","var2"]
df.drop(l, axis=1)  #Fancy ile silme<jupyter_output><empty_output><jupyter_text>**Gözlem ve Değişken Seçimi: loc & iloc**<jupyter_code>import numpy as np
import pandas as pd
m = np.random.randint(1,30, size=(10,3))
df = pd.DataFrame(m, columns=["var1","var2","var3"])
df<jupyter_output><empty_output><jupyter_text>**loc:** tanımlandığı şekliyle seçim yapmak için kullanılır<jupyter_code>df.loc[0:3] #veri setinin ilk halindeki indexlemeye sadik kalacak sekilde secim imkani verir.<jupyter_output><empty_output><jupyter_text>**iloc:** alışık olduğumuz index'leme mantığıyla seçim yapar.<jupyter_code>df.iloc[0:3]
df.iloc[0,0]
df.iloc[:3,:2]
df.loc[:3,"var3"]
df.iloc[:3,"var3"] # hata verir.<jupyter_output><empty_output><jupyter_text>Eğer değişken ya da satırlar ile ilgili mutlak bir değer işaretlemesi yapacaksakbu durumda **loc** kullanmamız gerekiyor. Yani değişken ismi ile işaretleme yapacaksak **loc** kullanmalıyız.Index'lere göre işaretleme yapacaksak **iloc** kullanmalıyız.<jupyter_code>df.iloc[:3,1:3]
df.iloc[:3]["var3"]<jupyter_output><empty_output><jupyter_text>**Koşullu Eleman İşlemleri**<jupyter_code>import numpy as np
import pandas as pd
m = np.random.randint(1,30, size=(10,3))
df = pd.DataFrame(m, columns=["var1","var2","var3"])
df
df.var1
df[df.var1 > 15]["var1"]
df[(df.var1 > 15) & (df.var3 < 5)]
df.loc[(df.var1 > 15),["var1","var2"]]
df[(df.var1 > 15)][["var1","var2"]]<jupyter_output><empty_output><jupyter_text>**Birleştirme (Join) İşlemleri**<jupyter_code>import pandas as pd
import numpy as np
m = np.random.randint(1,30, size=(5,3))
df1 = pd.DataFrame(m, columns=["var1","var2","var3"])
df1
df2 = df1 + 99
df2
pd.concat([df1,df2])<jupyter_output><empty_output><jupyter_text>Birleştirme işlemi yaptık fakat indexlerde bir karmaşıklık oldu.<jupyter_code>pd.concat([df1,df2],ignore_index = True)
df2.columns
df2.columns = ["var1","var2","deg3"]
df2
df1
pd.concat([df1, df2])<jupyter_output><empty_output><jupyter_text>Bir veri setinin diğerinde karşılığı olmadığı için böyle bir sorun yaşıyoruz. Bu sorunu kısmi olarak aşabiliriz. **join = "inner"** argümanı ile veri setlerinin kesişimlerini alabiliriz.<jupyter_code>pd.concat([df1,df2], join="inner") #kesisimlerini alir.
pd.concat([df1, df2], axis=1).reindex(df1.index)<jupyter_output><empty_output><jupyter_text>**İleri Birleştirme İşlemleri** **Birebir Birleştirme**: Tüm elemanların iki veri setinde de birebir yer alması durumudur.<jupyter_code>import pandas as pd
df1 = pd.DataFrame({"calisanlar":["Ali","Veli","Ayse","Fatma"],
                "grup":["Muhasebe","Muhendislik","Muhendislik","IK"]})
df1
df2 = pd.DataFrame({"calisanlar":["Ali","Veli","Ayse","Fatma"],
                "ilk_giris":[2010,2009,2014,2019]})
df2
pd.merge(df1,df2)<jupyter_output><empty_output><jupyter_text>**Merge()** Fonksiyonu birleştirme işleminin hangi değişkene göre yapılacağını kendisi anlıyor. Eğer bunu belirtmek istersek **on** argümanı aracılığı ile belirtebiliriz.Her iki veri setinde de calisanlar olduğu için bu veri setlerini calisanlar’a göre birleştirdi.<jupyter_code>pd.merge(df1, df2, on="calisanlar")<jupyter_output><empty_output><jupyter_text>**Many to one** (Çoktan teke)<jupyter_code>df3 = pd.merge(df1,df2)
df3
df4 = pd.DataFrame({"grup":["Muhasebe","Muhendislik","IK"],
                   "mudur":["Caner","Mustafa","Berkcan"]})
df4
pd.merge(df3,df4) #Many to one birlestirme.<jupyter_output><empty_output><jupyter_text>**Many to Many** (Çoktan çoka)<jupyter_code>df5 = pd.DataFrame({'grup' : ['Muhasebe','Muhasebe','Muhendislik','Muhendislik','IK','IK'],
                   'yetenekler' : ['Matematik','Excel','Kodlama','Linux','Excel','Yonetim']})
df5
df1
pd.merge(df1,df5) #Many to Many<jupyter_output><empty_output><jupyter_text>**Aggregation & Grouping** (Toplulaştırma ve Gruplama) Basit toplulaştırma fonksiyonları:* count()* first()* last()* mean()* median()* min()* max()* std()* var()* sum()<jupyter_code>import seaborn as sns #Bu kütüphanemiz içerisindeki bazı veri setlerini kullanıcaz.
df = sns.load_dataset("planets") #planets isimli dataset'i kullandik.
df
df.head()<jupyter_output><empty_output><jupyter_text>Artık satırlara **gözlem**, sütunlara ise **değişken** demeye alışmalıyız.<jupyter_code>df.shape<jupyter_output><empty_output><jupyter_text>dataset'in 1035 gözlem, 6 değişkenden oluştuğunu gözlemlemekteyiz.<jupyter_code>df.mean() #Tüm değişkenlerin ortalamaları
df["mass"].mean() # mass değişkeninin ortalaması.
df.count() #Degiskenlerdeki gözlem sayıları.
df.min() #Minimum değerler
df.max() #Maximum değerler
df.sum() # Değişkenlerin değerlerinin toplamı
df.std() #Değişkenlerin standart sapması
df.var() #Değişkenlerin varyansı
df.describe() #Verisetindeki tüm değişkenleri betimsel istatistikleri anlamında görebiliyoruz.
df.describe().T #Transpozu alındığında<jupyter_output><empty_output><jupyter_text>Elimizdeki verisetinin eksik gözlemleri silip describe yapmak istediğimizde**dropna()** fonskiyonunu kullanırız.<jupyter_code>df.dropna().describe().T<jupyter_output><empty_output><jupyter_text>**Grouping**<jupyter_code>import pandas as pd
df = pd.DataFrame({'gruplar' : ['A','B','C','A','B','C'],
                  'veri' : [10,11,52,23,43,55]}, columns=['gruplar','veri'])
df<jupyter_output><empty_output><jupyter_text>Genelde gruplama işlemleri ile toplulaştırma(Aggregation) işlemleri bir arada kullanılır.<jupyter_code>df.groupby("gruplar") #gruplar içerisindeki grupları yakaladı.
df.groupby("gruplar").mean() # Ortalamasini aldi.
df.groupby("gruplar").sum()
import seaborn as sns
df = sns.load_dataset("planets")
df.head()
df.groupby("method")["orbital_period"].describe()
#method'a göre grupla. orbital_period değişkeninin istatistiki degerlerini al.<jupyter_output><empty_output><jupyter_text>**İleri Toplulaştırma İşlemleri**(Aggregate, filter, transform, apply)  **Aggregate**<jupyter_code>import pandas as pd
df = pd.DataFrame({"gruplar" : ["A","B","C","A","B","C"],
                  "degisken1" : [10,23,33,22,11,99],
                  "degisken2" : [100,253,333,262,111,969]},
                 columns = ["gruplar","degisken1","degisken2"])
df
df.groupby("gruplar").mean()
import numpy as np
df.groupby("gruplar").aggregate(["min", np.median, max])

#Yaptığımız gruplama içerisinde kendi istediğimiz istatistiki değerleri
#bir arada görmek için aggragate kullanırız.<jupyter_output><empty_output><jupyter_text>İki değişken için iki ayrı istatistiki hesaplama yapmak istiyoruz.<jupyter_code>df.groupby("gruplar").aggregate({"degisken1" : "min", "degisken2" : np.median})<jupyter_output><empty_output><jupyter_text>**Filter** Pandas'ın sunduğu özelliklerden daha karmaşık bir isteğimizolduğunda kendi fonksiyonumuzu yazıp ona göre filtreleyebiliriz.<jupyter_code>import pandas as pd
df = pd.DataFrame({"gruplar" : ["A","B","C","A","B","C"],
                  "degisken1" : [10,23,33,22,11,99],
                  "degisken2" : [100,253,333,262,111,969]},
                 columns = ["gruplar","degisken1","degisken2"])
df

def filter_func(x):
    return x["degisken1"].std() > 9
#degisken1'e göre standart sapması 9'dan büyük olan değerler
df.groupby("gruplar").std() #standart sapmalar
df.groupby("gruplar").filter(filter_func)<jupyter_output><empty_output><jupyter_text>Aynı işlemin **lambda** ile çözümü:<jupyter_code>df.groupby("gruplar").filter(lambda x : x["degisken1"].std() > 9)<jupyter_output><empty_output><jupyter_text>**transform** Kendi tanımladığımız bir fonksiyonu değişkenler üzerinde uygulayabiliyoruz.<jupyter_code>import pandas as pd
df = pd.DataFrame({"gruplar" : ["A","B","C","A","B","C"],
                  "degisken1" : [10,23,33,22,11,99],
                  "degisken2" : [100,253,333,262,111,969]},
                 columns = ["gruplar","degisken1","degisken2"])
df
df["degisken1"]*9
df_a = df.iloc[:, 1:3]
df_a<jupyter_output><empty_output><jupyter_text>Birazdan yapacağımız işlem sayısal bir işlem olduğundan gruplar değişkenineuygulamak istediğimizde hata ile karşılaşmamak için, yukarıdaki gibi gruplar'ıayrı tutmamız gerekiyor.<jupyter_code>df_a.transform(lambda x : x-x.mean())
#yakalamış olduğu bütün elemanlardan o değişkenin ortalamasını çıkartacak.<jupyter_output><empty_output><jupyter_text>**Apply**<jupyter_code>import pandas as pd
import numpy as np
df = pd.DataFrame({"degisken1" : [10,23,33,22,11,99],
                  "degisken2" : [100,253,333,262,111,969]},
                 columns = ["degisken1","degisken2"])
df<jupyter_output><empty_output><jupyter_text>**apply()** fonksiyonu tıpkı transform fonksiyonu ve filter fonksiyonu gibideğişkenlerin üzerinde gezinme yeteneği olan ve **aggregation**(toplulaştırma)amacıyla kullanılacak olan bir fonksiyondur.<jupyter_code>df.apply(np.sum)
df.apply(np.mean)
df = pd.DataFrame({"gruplar" : ["A","B","C","A","B","C"],
                    "degisken1" : [10,23,33,22,11,99],
                  "degisken2" : [100,253,333,262,111,969]},
                 columns = ["gruplar","degisken1","degisken2"])
df
df.groupby("gruplar").apply(np.sum)
df
df.groupby("gruplar").apply(lambda x : (x["degisken1"]-x["degisken2"]))<jupyter_output><empty_output><jupyter_text>Bu işlemi apply ile yapabiliriz ancak transform hata verir.  **Pivot Tablolar** Veri setleri üzerinde bazı satır ve sütun işlemleri yaparak, veri setini amaca uygun hale getirmek için kullanılan yapılardır. **groupby()**'ın çok boyutlu versiyonu olarak düşünülebilir.<jupyter_code>import pandas as pd
import seaborn as sns
titanic = sns.load_dataset("titanic")
titanic<jupyter_output><empty_output><jupyter_text>Cinsiyete göre gruplayıp hayatta olma ortalamalarına bakalım.<jupyter_code>titanic.groupby("sex")["survived"].mean() 
titanic.groupby("sex")[["survived"]].mean()  #Basit bir pivot işlemi.
# değişken etrafına köşeli parantez ekleyerek dataset olarak gözlemleyelim.<jupyter_output><empty_output><jupyter_text>Cinsiyete ve class'a göre ölüm ortalamaları:<jupyter_code>titanic.groupby(["sex","class"])[["survived"]].aggregate("mean")
titanic.groupby(["sex","class"])["survived"].aggregate("mean").unstack()
#unstack bizi hiyerarsik görünümden kurtarır.,<jupyter_output><empty_output><jupyter_text>Bir boyut daha ekleyerek pivot table oluşturduk.<jupyter_code>#Pivot ile table
titanic.pivot_table("survived", index = "sex", columns = "class")
titanic.age<jupyter_output><empty_output><jupyter_text>Bu sürekli değişkeni bir kategorik değişkene çevirip, bu kategorik değişkenin sınıflarını da pivot table'a boyut olarak ekleyelim.<jupyter_code>age = pd.cut(titanic["age"], [0,18,90])
age.head(15)<jupyter_output><empty_output><jupyter_text>Sürekli bir değişken olan age değişkenini kategorik değişken haline getirdik.<jupyter_code>titanic.pivot_table("survived",["sex",age], "class")<jupyter_output><empty_output><jupyter_text>**Dış Kaynaklı Veri Okuma** **.txt** formunu ve **.csv** formunu aynı fonksiyon ile okuyabiliyoruz.<jupyter_code>import pandas as pd
pd.read_csv("reading_data/ornekcsv.csv")<jupyter_output><empty_output><jupyter_text>Veri düzgün biçimde gelmedi. Veri okuma işlemlerinde en sık karşılaşılan problem budur.Paylaşılan veri seti genellikle csv ya da txt formunda olduğunda değişkenler birbirindenbazı ayraçlar ile ayrılır. Ayraç olarak öntanımlı değer **","**'dür. Bize gelen veride ise **";"** kullanılmış.**sep** argümanı ile bu sorunu çözebiliriz.<jupyter_code>#csv okuma
pd.read_csv("reading_data/ornekcsv.csv", sep=";")
#txt okuma
pd.read_csv("reading_data/duz_metin.txt")<jupyter_output><empty_output><jupyter_text>sep argümanını kullanmadık fakat veriler düzgün biçimde geldi.Düz metinlerde arada boşluk olsa dahi bunu fonksiyon görebiliyor.  **Excel Dosyası Okuma**<jupyter_code>pd.read_excel("reading_data/ornekx.xlsx")
df = pd.read_excel("reading_data/ornekx.xlsx")
type(df)<jupyter_output><empty_output><jupyter_text>DataFrame'lere yaptığımız tüm işlemleri artık burada da yapabiliriz.<jupyter_code>df.head()
df.columns = ("A", "B", "C") #column isimlerini değiştirdik.
df<jupyter_output><empty_output><jupyter_text>GitHub'da tek bir veri setini almak istediğimizde, veri setinin olduğu sayfada **Raw**butonuna tıklayıp verisetinin ham haline ulaşabiliriz. Buradaki verileri txt dosyasınakopyalayıp kullanabiliriz.<jupyter_code>#sıfırdan txt okuma
tips = pd.read_csv("reading_data/data.txt")
tips<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14972414602652895, 'fraction_numerical': 0.028876628712290176, 'mean_word_length': 7.675661914460285, 'pattern_counts': {'":': 14, '<': 226, '<?xml version=': 0, '>': 231, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '56', 'dir': 'jupyter-structured-clean-dedup', 'id': '34704', 'license': 'MIT', 'n_tokens_mistral': 7852, 'n_tokens_neox': 7387, 'n_words': 1225, 'path': 'Manipulation/Pandas.ipynb', 'repo_name': 'SevdanurGENC/Data-Analytics-Lecture-Notes', 'size': '17044'}