Yapay Zeka Dersleri ve Projeleri

Veri Bilimi & Veri Manipülasyonu - Pandas

Seri Yöntemleri

Yazar: Enes ASAN

Yayın tarihi :18-Ara-21

Serilere ait bazı önemli yöntemler listelenmiştir.

Aşağıdaki seri yöntemlerinde kullanmak üzere "mySeries1" ve "mySeries2" isimlerinde iki adet "Pandas Serisi" tanımlandı.

import pandas as pd

import numpy as np

myArray1=np.array(np.random.randint(-10,20,5))
mySeries1=pd.Series(myArray1)
mySeries1

Çıktı:

0    19
1    -1
2     8
3     5
4     6
dtype: int32

mySeries2=pd.Series(["A","B","C","D","E"])
mySeries2

Çıktı:

0    A
1    B
2    C
3    D
4    E
dtype: object

abs(): Seri öğelerinin mutlak değerini alarak döndürür.
```
mySeries1.abs()
```
Çıktı:
```
0    19
1     1
2     8
3     5
4     6
dtype: int32
```

add(): Seri öğelerini verilecek değerlerle toplar.

mySeries1.add(10)

Çıktı:

0    29
1     9
2    18
3    15
4    16
dtype: int32

mySeries2.add("_harfi")

Çıktı:

0    A_harfi
1    B_harfi
2    C_harfi
3    D_harfi
4    E_harfi
dtype: object

add_prefix(): Seri index değerinin başına ilgili değeri ekler.

mySeries2.add_prefix("a_")

Çıktı:

a_0    A
a_1    B
a_2    C
a_3    D
a_4    E
dtype: object

add_suffix(): Seri index değerinin sonuna ilgili değeri ekler.

mySeries2.add_suffix("_b")

Çıktı:

0_b    A
1_b    B
2_b    C
3_b    D
4_b    E
dtype: object

agg([fonksiyon,eksen]): Her elemana ilgili fonksiyon değerini uygular.

#her eleman değerini kendisi ile çarpan bir fonksiyon uygulandı.
mySeries1.agg(lambda x:x*x,axis=0)

Çıktı:

0    361
1      1
2     64
3     25
4     36
dtype: int64

aggregate([fonksiyon,eksen]): Her elemana ilgili fonsiyonları uygular.
```
mySeries1.aggregate([lambda x:x*x,lambda x:x+x],axis=0)
```
Çıktı:

append(): İki veya daha fazla seriyi birleştirmek için kullanılır.

mySeries1.append(mySeries2,ignore_index=True) #ignore_index=True index değerlerini düzenler

Çıktı:

0    19
1    -1
2     8
3     5
4     6
5     A
6     B
7     C
8     D
9     E
dtype: object

apply(): Seri değerlerine ilgili fonksiyonu uygular.

#1.Yöntem
mySeries1.apply(lambda x:x/4)

Çıktı:

0    4.75
1   -0.25
2    2.00
3    1.25
4    1.50
dtype: float64

#2.Yöntem
def bol(x,y):
    return x/y
mySeries1.apply(bol,args=(4,))

Çıktı:

0    4.75
1   -0.25
2    2.00
3    1.25
4    1.50
dtype: float64

argmax(): Serideki en büyük değerin index değerini döndürür.
```
mySeries1.argmax()
```
Çıktı:
```
0
```
argmin(): Serideki en küçük değerinin index değerini döndürür.
```
mySeries1.argmin()
```
Çıktı:
```
1
```
argsort(): Serideki değerleri sıralayarak küçükten büyüğe index değerlerini sıralar.
```
mySeries1.argsort()
```
Çıktı:
```
0    1
1    3
2    4
3    2
4    0
dtype: int64
```

astype(): Serinin tipini değiştirmek için kullanılır.

#Serinin dtype'ı object olarak güncellendi.
mySeries1.astype(dtype="object")

Çıktı:

0    19
1    -1
2     8
3     5
4     6
dtype: object

#Serinin dtype'ı float olarak güncellendi.
mySeries1.astype(dtype="float")

Çıktı:

0    19.0
1    -1.0
2     8.0
3     5.0
4     6.0
dtype: float64

compare(): İki seriyi karşılaştırarak aradaki farkları tablo halinde gösterir.
```
mySeries1.compare(mySeries2)
```
Çıktı:
convert_dtypes(): Serinin veri tiplerine bakarak en uygun veri tipini döndürür.
```
mySeries2.convert_dtypes()
```
Çıktı:
```
0    A
1    B
2    C
3    D
4    E
dtype: string
```

copy(): Serinin bir kopyasını oluşturmak için kullanılır.

mySeries3=mySeries1.copy()
mySeries3

Çıktı:

0    19
1    -1
2     8
3     5
4     6
dtype: int32

corr(): Serinin eksik değerleri hariç diğer serilerle korelasyonunu hesaplar.
```
mySeries3=pd.Series([1,2,3,4,5])
mySeries1.corr(mySeries3)
```
Çıktı:
```
-0.4331480818242099
```
count(): Serinin satır sayısını hesaplar.
```
mySeries1.count()
```
Çıktı:
```
5
```
cov(): Serinin eksik değerleri hariç diğer serilerle kovaryansını hesaplar.
```
mySeries3=pd.Series([1,2,3,4,5])
mySeries1.cov(mySeries3)
```
Çıktı:
```
-5.0
```

cummin(): Serinin kümülatif minimum değerini döndürür.

mySeries1.cummin()

Çıktı:

0    19
1    -1
2    -1
3    -1
4    -1
dtype: int32

cummax(): Serinin kümülatif maksimum değerini döndürür

mySeries1.cummax()

Çıktı:

0    19
1    19
2    19
3    19
4    19
dtype: int32

cumsum(): Serinin kümülatif toplamı döndürür. Yani ilk satırdan başlayarak aşağı doğru seri elemanlarını toplayarak ilerler.
```
mySeries1.cumsum()
```
Çıktı:
```
0    19
1    18
2    26
3    31
4    37
dtype: int32
```

describe(): Seri hakkında genel bilgilendirme yapar.

mySeries1.describe()

Çıktı:

count     5.000000
mean      7.400000
std       7.300685
min      -1.000000
25%       5.000000
50%       6.000000
75%       8.000000
max      19.000000
dtype: float64

dot(): Seri elemanlarını sırasına göre diğer seri ile çarparak toplamı döndürür.
```
mySeries1.dot(mySeries1)
```
Çıktı:
```
487
```

drop(): Seri elemanlarını kaldırmak için kullanılır.

#0 ve 1 sütunları kaldırıldı.
mySeries1.drop(labels=[0,1],axis=0)

Çıktı:

2    8
3    5
4    6
dtype: int32

drop_duplicates(): Seri içersinde yinelenen değerleri kaldırmak için kullanılır.

mySeries3=pd.Series([1,2,3,3,4,4,5,6])
mySeries3.drop_duplicates()

Çıktı:

0    1
1    2
2    3
4    4
6    5
7    6
dtype: int64

dropna(): Serideki nan değerleri kaldırmak için kullanılır.

import numpy as np
mySeries3=pd.Series([1,2,3,np.nan,np.nan])
mySeries3

Çıktı:

0    1.0
1    2.0
2    3.0
3    NaN
4    NaN
dtype: float64

mySeries3.dropna()

Çıktı:

0    1.0
1    2.0
2    3.0
dtype: float64

dt: Seri içersinde bulunan zamanları yıl,ay, gün, saat, dakika, saniye gibi öğelerine ayırmak için kullanılır.

mySeries3=pd.Series(pd.date_range("2022-01-01 10:00:00",periods=5,freq="d"))
mySeries3

Çıktı:

0   2022-01-01 10:00:00
1   2022-01-02 10:00:00
2   2022-01-03 10:00:00
3   2022-01-04 10:00:00
4   2022-01-05 10:00:00
dtype: datetime64[ns]

mySeries3.dt.day

Çıktı:

0    1
1    2
2    3
3    4
4    5
dtype: int64

mySeries3.dt.day_name()

Çıktı:

0     Saturday
1       Sunday
2       Monday
3      Tuesday
4    Wednesday
dtype: object

mySeries3.dt.month_name()

Çıktı:

0    January
1    January
2    January
3    January
4    January
dtype: object

duplicated(): Serideki yinlenen değerleri True olarak döndürür.

mySeries3=pd.Series([1,2,3,3,4,4,5,6])
mySeries3.duplicated()

Çıktı:

0    False
1    False
2    False
3     True
4    False
5     True
6    False
7    False
dtype: bool

equals(): İki serinin aynı değerleri içerip içermediğini döndürür.
```
mySeries1.equals(mySeries1)
```
Çıktı:
```
True
```
```
mySeries1.equals(mySeries2)
```
Çıktı:
```
False
```

explode(): Seri içersinde liste halinde bulunan öğeleri satır olarak dönüştürür.

mySeries3=pd.Series([[1,2],["Ankara","İstanbul"],[],2])
mySeries3

Çıktı:

0                [1, 2]
1    [Ankara, İstanbul]
2                    []
3                     2
dtype: object

mySeries3.explode()

Çıktı:

0           1
0           2
1      Ankara
1    İstanbul
2         NaN
3           2
dtype: object

fillna(): NaN değerleri istenilen değerle doldurur.

import numpy as np
mySeries3=pd.Series([1,2,3,np.nan,np.nan])
mySeries3.fillna(5) #2 tane nan değerini 5 ile doldurduk.

Çıktı:

0    1.0
1    2.0
2    3.0
3    5.0
4    5.0
dtype: float64

import numpy as np
mySeries3=pd.Series([1,2,3,np.nan,np.nan])
mySeries3.fillna(mySeries3.median(),inplace=True) #nan değerleri orta değer ile doldurduk, ve inplace=True direkt olarak yapılan işlemin serinin içine işlemesini sağlar.
mySeries3

Çıktı:

0    1.0
1    2.0
2    3.0
3    2.0
4    2.0
dtype: float64

groupby(): Serileri gruplayarak döndürür.

mySeries3=pd.Series(data=[1,2,3,4,5],index=["A","A","B","C","A"])
mySeries3

Çıktı:

A    1
A    2
B    3
C    4
A    5
dtype: int64

mySeries3.groupby(level=0).sum()

Çıktı:

A    8
B    3
C    4
dtype: int64

head(n): Serideki ilk "n" değerini döndür. n değeri varsayılan olarak 5'tir.
```
mySeries1.head(2)
```
Çıktı:
```
0    19
1    -1
dtype: int64
```

isin(): Seri elemanlarının ilgili değeri içerip içermediğini döndürür.

mySeries2.isin(["B"])

Çıktı:

0    False
1     True
2    False
3    False
4    False
dtype: bool

isnull(): Seri elemanlarının nan olup olmadığını döndürür.

import numpy as np
mySeries3=pd.Series([1,2,3,np.nan,np.nan])
mySeries3.isnull()

Çıktı:

0    False
1    False
2    False
3     True
4     True
dtype: bool

items(): Yineleyici nesne oluşturmak için kullanılır.

for i in mySeries1.items():
    print(i)

Çıktı:

(0, 19)
(1, -1)
(2, 8)
(3, 5)
(4, 6)

keys(): Seri elemanlarını index değerlerini döndürür.
```
for i in mySeries1.keys():
    print(i)
```
Çıktı:
```
0
1
2
3
4
```
mean(): Seri elemanlarının (sayısal değerli) ortalamasını döndürür.
```
mySeries1.mean()
```
Çıktı:
```
7.4
```
median(): Seri elemanlarını (sayılsal değerli) küçükten büyüğe sıralanmış halindeki orta değerini döndürür.
```
mySeries1.median()
```
Çıktı:
```
6.0
```
min(): Seri elemanlarının min değerini döndürür.
```
mySeries1.min()
```
Çıktı:
```
-1
```
```
mySeries2.min()
```
Çıktı:
```
'A'
```
max(): Seri elemanlarının max değerini döndürür.
```
mySeries1.max()
```
Çıktı:
```
19
```
```
mySeries2.max()
```
Çıktı:
```
'E'
```

mode(): Serideki en fazla geçen elemanı döndürür.

mySeries3=pd.Series([1,2,3,3,3,2,1,6])
mySeries3.mode()

Çıktı:

0    3
dtype: int64

multipy(): İki serideki elemanları çarpmak için kullanılır.

mySeries3=pd.Series([1,2,3,4])
mySeries4=pd.Series([-5,2,4,5])
mySeries3.multiply(mySeries4)

Çıktı:

0    -5
1     4
2    12
3    20
dtype: int64

notna(): Serinin değerlerinin NaN olup olmadığını döndürür.

import numpy as np
mySeries3=pd.Series([1,2,3,np.nan,np.nan])
mySeries3.notna()

Çıktı:

0     True
1     True
2     True
3    False
4    False
dtype: bool

nunique(): Serideki benzersiz elemanların sayısını döndürür.
```
mySeries3=pd.Series([1,2,3,3,3,2,1,6])
mySeries3.nunique()
```
Çıktı:
```
4
```
plot: Seri eleman değerleri ile grafik çizmek için kullanılır.(Veri görselleştirmesi dersinde detaylandırılmıştır.)
```
mySeries1.plot.hist()
```
Çıktı:

pow(): Serinin kuvvetini almak için kullanılır.

mySeries3=pd.Series([1,2,3,4])
mySeries4=pd.Series([5,2,4,5])
mySeries3.pow(mySeries4)

Çıktı:

0       1
1       4
2      81
3    1024
dtype: int64

rank(): Serinin elemanlarının rankını hesaplar.

mySeries1.rank()

Çıktı:

0    5.0
1    1.0
2    4.0
3    2.0
4    3.0
dtype: float64

rename(): Serinin ismini değiştirmek için kullanılır.

mySeries1.rename("YeniIsim")

Çıktı:

0    19
1    -1
2     8
3     5
4     6
Name: YeniIsim, dtype: int64

replace(): Serideki elemanları başka bir değerle değiştirme işlemi. replace(eski_deger,yeni_deger)
```
mySeries1.replace(5,99)
```
Çıktı:
```
0    19
1    -1
2     8
3    99
4     6
dtype: int64
```
reset_index(): Serideki index değerlerini yeniden sıralamak için kullanılır. Bir seri elemanı silindiğinde index değeri eski halinde kalır, index değerini tekrar sıralamak için reset_index() komutu kullanılır.
```
mySeries1.drop(1,inplace=True)
mySeries1
```
Çıktı:
```
0    19
2     8
3     5
4     6
dtype: int64
```
```
mySeries1.reset_index(drop=True)
```
Çıktı:
```
0    19
1     8
2     5
3     6
dtype: int64
```
sample(n): Seri elemanlarını "n" değerine göre rastgele olarak döndürür. "n" değeri varsayılan olarak 1'dir.
```
mySeries1.sample(2)
```
Çıktı:
```
3    5
1   -1
dtype: int64
```
sort_index(): Seri elemanlarını index değerine göre sıralama yapar. sort_index(ascending=False) büyükten küçüğe sıralama yapar.
```
mySeries1.sort_index(ascending=False)
```
Çıktı:
```
4     6
3     5
2     8
1    -1
0    19
dtype: int64
```

sort_values(): Seri elemanlarını değerlerine göre sıralama yapar. "sort_values(ascending=False)" büyükten küçüğe sıralama yapar.

mySeries1.sort_values(ascending=False)

Çıktı:

0    19
2     8
4     6
3     5
1    -1
dtype: int64

mySeries1.sort_values() #veya mySeries1.sort_values(ascending=True)

Çıktı:

1    -1
3     5
4     6
2     8
0    19
dtype: int64

sub(): İki serinin farkını almak için kullanılır.

mySeries3=pd.Series([1,2,3,4])
mySeries4=pd.Series([5,2,4,5])
mySeries3.sub(mySeries4)

Çıktı:

0   -4
1    0
2   -1
3   -1
dtype: int64

sum(): Seri elemanların değerlerini toplamak için kullanılır.
```
mySeries1.sum()
```
Çıktı:
```
37
```
tail(n): Serinin sondan "n" kadar elemanını almak için kullanılır. "n" değeri varsayılan olarak 5'tir.
```
mySeries1.tail(3)
```
Çıktı:
```
2    8
3    5
4    6
dtype: int64
```
take(): Seri elemanlarının belirli değerlerini almak için kullanılır.
```
mySeries1.take([2,4])
```
Çıktı:
```
2    8
4    6
dtype: int64
```
unique(): Seri elemanlarının benzersiz değerlerini döndürür. (nunique() komutu sayısını döndürmekteydi.)
```
mySeries3=pd.Series([1,2,3,3,3,2,1,6])
mySeries3.unique()
```
Çıktı:
```
array([1, 2, 3, 6], dtype=int64)
```

value_counts(): Seri elemanlarının benzersiz değerlerinin sayısını döndürür.

mySeries3=pd.Series([1,2,3,3,3,2,1,6])
mySeries3.value_counts()

Çıktı:

3    3
1    2
2    2
6    1
dtype: int64

Seri Öznitelikleri

DataFrame Oluşturma

Paylaş:

Yorumlar

Henüz hiç yorum yapılmamış, ilk yorum yapan sen ol.

Veri Bilimi & Veri Manipülasyonu

I. Veri Bilimine Giriş

II. Numpy

III. Pandas

IV. Keşfedici Veri Analizi

Veri Bilimi & Veri Manipülasyonu - Pandas

Seri Yöntemleri

Yorumlar