02- Pandas Kütüphanesi
Pandas kutuphanesi verileri pratik bir şekilde görselleştirmede kullandığımız kütüphanedir.
Pandas 10 dakika
Bu, esas olarak yeni kullanıcılar için tasarlanmış pandalara kısa bir giriş niteliğindedir. Daha karmaşık tarifleri görebilirsiniz. Yemek kitabı.
Genellikle, aşağıdaki gibi içe aktarırız:
1
2
3
In [1]: import numpy as np
In [2]: import pandas as pd
Pandalarda temel veri yapıları
Pandas, verileri işlemek için iki tür sınıf sağlar:
Series: her tür veriyi tutan tek boyutlu etiketli dizi
tamsayılar, dizeler, Python nesneleri vb.
DataFrame: verileri tutan iki boyutlu bir veri yapısı iki boyutlu bir dizi veya satır ve sütun içeren bir tablo.
Nesne oluşturma
Görmek Veri yapıları bölümüne giriş.
Bir Oluşturma Series bir değer listesi geçirerek pandaların yaratılmasına izin vererek varsayılan RangeIndex.
1
2
3
4
5
6
7
8
9
10
11
In [3]: s = pd.Series([1, 3, 5, np.nan, 6, 8])
In [4]: s
Out[4]:
0 1.0
1 3.0
2 5.0
3 NaN
4 6.0
5 8.0
dtype: float64
Bir Oluşturma DataFrame datetime dizinine sahip bir NumPy dizisini kullanarak date_range() ve etiketli sütunlar:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
In [5]: dates = pd.date_range("20130101", periods=6)
In [6]: dates
Out[6]:
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
'2013-01-05', '2013-01-06'],
dtype='datetime64[ns]', freq='D')
In [7]: df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD"))
In [8]: df
Out[8]:
A B C D
2013-01-01 0.469112 -0.282863 -1.509059 -1.135632
2013-01-02 1.212112 -0.173215 0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929 1.071804
2013-01-04 0.721555 -0.706771 -1.039575 0.271860
2013-01-05 -0.424972 0.567020 0.276232 -1.087401
2013-01-06 -0.673690 0.113648 -1.478427 0.524988
Bir Oluşturma DataFrame anahtarların sütun olduğu nesnelerin sözlüğünü geçirerek etiketler ve değerler sütun değerleridir.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
In [9]: df2 = pd.DataFrame(
...: {
...: "A": 1.0,
...: "B": pd.Timestamp("20130102"),
...: "C": pd.Series(1, index=list(range(4)), dtype="float32"),
...: "D": np.array([3] * 4, dtype="int32"),
...: "E": pd.Categorical(["test", "train", "test", "train"]),
...: "F": "foo",
...: }
...: )
...:
In [10]: df2
Out[10]:
A B C D E F
0 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
2 1.0 2013-01-02 1.0 3 test foo
3 1.0 2013-01-02 1.0 3 train foo
Ortaya çıkan sütunlar DataFrame farklı dtypes:
1
2
3
4
5
6
7
8
9
In [11]: df2.dtypes
Out[11]:
A float64
B datetime64[s]
C float32
D int32
E category
F object
dtype: object
IPython kullanıyorsanız, sütun adları (ve genel) için sekme tamamlama öznitelikler) otomatik olarak etkinleştirilir. İşte özelliklerin bir alt kümesi tamamlanacak:
1
2
3
4
5
6
7
8
9
10
11
12
13
In [12]: df2.<TAB> # noqa: E225, E999
df2.A df2.bool
df2.abs df2.boxplot
df2.add df2.C
df2.add_prefix df2.clip
df2.add_suffix df2.columns
df2.align df2.copy
df2.all df2.count
df2.any df2.combine
df2.append df2.D
df2.apply df2.describe
df2.applymap df2.diff
df2.B df2.duplicated
Gördüğünüz gibi sütunlar A, B, C, ve D otomatik olarak sekme tamamlandı. E ve F orada da var mı; diğer özellikler kısalık için kesilmiş.
Verileri görüntüleme
Görmek Temel olarak işlevsellik bölümü.
Kullanmak DataFrame.head() ve DataFrame.tail() çerçevenin üst ve alt sıralarını görüntülemek için sırasıyla:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
In [13]: df.head()
Out[13]:
A B C D
2013-01-01 0.469112 -0.282863 -1.509059 -1.135632
2013-01-02 1.212112 -0.173215 0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929 1.071804
2013-01-04 0.721555 -0.706771 -1.039575 0.271860
2013-01-05 -0.424972 0.567020 0.276232 -1.087401
In [14]: df.tail(3)
Out[14]:
A B C D
2013-01-04 0.721555 -0.706771 -1.039575 0.271860
2013-01-05 -0.424972 0.567020 0.276232 -1.087401
2013-01-06 -0.673690 0.113648 -1.478427 0.524988
Görüntüleme DataFrame.index veya DataFrame.columns:
1
2
3
4
5
6
7
8
In [15]: df.index
Out[15]:
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
'2013-01-05', '2013-01-06'],
dtype='datetime64[ns]', freq='D')
In [16]: df.columns
Out[16]: Index(['A', 'B', 'C', 'D'], dtype='object')
Temel verilerin bir NumPy temsilini DataFrame.to_numpy() dizin veya sütun etiketleri olmadan:
1
2
3
4
5
6
7
8
In [17]: df.to_numpy()
Out[17]:
array([[ 0.4691, -0.2829, -1.5091, -1.1356],
[ 1.2121, -0.1732, 0.1192, -1.0442],
[-0.8618, -2.1046, -0.4949, 1.0718],
[ 0.7216, -0.7068, -1.0396, 0.2719],
[-0.425 , 0.567 , 0.2762, -1.0874],
[-0.6737, 0.1136, -1.4784, 0.525 ]])
Not
Pandalar DataFrames iken NumPy dizileri tüm dizi için bir dtype’a sahiptir sütun başına bir dtype’a sahip. Aradığın zaman DataFrame.to_numpy(), pandalar olacak tutabilecek NumPy dtype’ını bulun hepsi DataFrame içindeki dtypes. Ortak veri türü object, DataFrame.to_numpy() gerektirecek veri kopyalama.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
In [18]: df2.dtypes
Out[18]:
A float64
B datetime64[s]
C float32
D int32
E category
F object
dtype: object
In [19]: df2.to_numpy()
Out[19]:
array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo'],
[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo']],
dtype=object)
describe()verilerinizin hızlı bir istatistik özetini gösterir:
1
2
3
4
5
6
7
8
9
10
11
In [20]: df.describe()
Out[20]:
A B C D
count 6.000000 6.000000 6.000000 6.000000
mean 0.073711 -0.431125 -0.687758 -0.233103
std 0.843157 0.922818 0.779887 0.973118
min -0.861849 -2.104569 -1.509059 -1.135632
25% -0.611510 -0.600794 -1.368714 -1.076610
50% 0.022070 -0.228039 -0.767252 -0.386188
75% 0.658444 0.041933 -0.034326 0.461706
max 1.212112 0.567020 0.276232 1.071804
Verilerinizi aktarma:
1
2
3
4
5
6
7
In [21]: df.T
Out[21]:
2013-01-01 2013-01-02 2013-01-03 2013-01-04 2013-01-05 2013-01-06
A 0.469112 1.212112 -0.861849 0.721555 -0.424972 -0.673690
B -0.282863 -0.173215 -2.104569 -0.706771 0.567020 0.113648
C -1.509059 0.119209 -0.494929 -1.039575 0.276232 -1.478427
D -1.135632 -1.044236 1.071804 0.271860 -1.087401 0.524988
DataFrame.sort_index()bir eksene göre sıralar:
1
2
3
4
5
6
7
8
9
In [22]: df.sort_index(axis=1, ascending=False)
Out[22]:
D C B A
2013-01-01 -1.135632 -1.509059 -0.282863 0.469112
2013-01-02 -1.044236 0.119209 -0.173215 1.212112
2013-01-03 1.071804 -0.494929 -2.104569 -0.861849
2013-01-04 0.271860 -1.039575 -0.706771 0.721555
2013-01-05 -1.087401 0.276232 0.567020 -0.424972
2013-01-06 0.524988 -1.478427 0.113648 -0.673690
DataFrame.sort_values()değerlere göre sıralar:
1
2
3
4
5
6
7
8
9
In [23]: df.sort_values(by="B")
Out[23]:
A B C D
2013-01-03 -0.861849 -2.104569 -0.494929 1.071804
2013-01-04 0.721555 -0.706771 -1.039575 0.271860
2013-01-01 0.469112 -0.282863 -1.509059 -1.135632
2013-01-02 1.212112 -0.173215 0.119209 -1.044236
2013-01-06 -0.673690 0.113648 -1.478427 0.524988
2013-01-05 -0.424972 0.567020 0.276232 -1.087401
seçim
Dizin oluşturma belgelerine bakın Dizin Oluşturma ve Veri Seçme ve MultiIndex / Gelişmiş Dizin Oluşturma.
Getitem ([])
İçin DataFrametek bir etiketin geçmesi bir sütun seçer ve bir Series eşdeğer df.A:
1
2
3
4
5
6
7
8
9
In [24]: df["A"]
Out[24]:
2013-01-01 0.469112
2013-01-02 1.212112
2013-01-03 -0.861849
2013-01-04 0.721555
2013-01-05 -0.424972
2013-01-06 -0.673690
Freq: D, Name: A, dtype: float64
İçin DataFrame, bir dilim geçiyor : eşleşen satırları seçer:
1
2
3
4
5
6
7
8
9
10
11
12
13
In [25]: df[0:3]
Out[25]:
A B C D
2013-01-01 0.469112 -0.282863 -1.509059 -1.135632
2013-01-02 1.212112 -0.173215 0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929 1.071804
In [26]: df["20130102":"20130104"]
Out[26]:
A B C D
2013-01-02 1.212112 -0.173215 0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929 1.071804
2013-01-04 0.721555 -0.706771 -1.039575 0.271860
Etikete göre seçim
Daha fazlasını görmek Etikete Göre Seçim kullanarak DataFrame.loc() veya DataFrame.at().
Bir etiketle eşleşen bir satır seçme:
1
2
3
4
5
6
7
In [27]: df.loc[dates[0]]
Out[27]:
A 0.469112
B -0.282863
C -1.509059
D -1.135632
Name: 2013-01-01 00:00:00, dtype: float64
Tüm satırları seçme (:) belirli bir sütun etiketi ile:
1
2
3
4
5
6
7
8
9
In [28]: df.loc[:, ["A", "B"]]
Out[28]:
A B
2013-01-01 0.469112 -0.282863
2013-01-02 1.212112 -0.173215
2013-01-03 -0.861849 -2.104569
2013-01-04 0.721555 -0.706771
2013-01-05 -0.424972 0.567020
2013-01-06 -0.673690 0.113648
Etiket dilimleme için her iki uç nokta dahil:
1
2
3
4
5
6
In [29]: df.loc["20130102":"20130104", ["A", "B"]]
Out[29]:
A B
2013-01-02 1.212112 -0.173215
2013-01-03 -0.861849 -2.104569
2013-01-04 0.721555 -0.706771
Tek bir satır ve sütun etiketi seçmek bir skaler döndürür:
1
2
In [30]: df.loc[dates[0], "A"]
Out[30]: 0.4691122999071863
Bir skalere hızlı erişim elde etmek için (önceki yönteme eşdeğer):
1
2
In [31]: df.at[dates[0], "A"]
Out[31]: 0.4691122999071863
Konuma göre seçim
Daha fazlasını görmek Konuma Göre Seçim kullanarak DataFrame.iloc() veya DataFrame.iat().
Geçen tamsayıların konumu üzerinden seçim yapın:
1
2
3
4
5
6
7
In [32]: df.iloc[3]
Out[32]:
A 0.721555
B -0.706771
C -1.039575
D 0.271860
Name: 2013-01-04 00:00:00, dtype: float64
Tamsayı dilimleri NumPy / Python’a benzer:
1
2
3
4
5
In [33]: df.iloc[3:5, 0:2]
Out[33]:
A B
2013-01-04 0.721555 -0.706771
2013-01-05 -0.424972 0.567020
Tamsayı konum konum konumlarının listesi:
1
2
3
4
5
6
In [34]: df.iloc[[1, 2, 4], [0, 2]]
Out[34]:
A C
2013-01-02 1.212112 0.119209
2013-01-03 -0.861849 -0.494929
2013-01-05 -0.424972 0.276232
Satırları açıkça dilimlemek için:
1
2
3
4
5
In [35]: df.iloc[1:3, :]
Out[35]:
A B C D
2013-01-02 1.212112 -0.173215 0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929 1.071804
Sütunları açıkça dilimlemek için:
1
2
3
4
5
6
7
8
9
In [36]: df.iloc[:, 1:3]
Out[36]:
B C
2013-01-01 -0.282863 -1.509059
2013-01-02 -0.173215 0.119209
2013-01-03 -2.104569 -0.494929
2013-01-04 -0.706771 -1.039575
2013-01-05 0.567020 0.276232
2013-01-06 0.113648 -1.478427
Açıkça bir değer elde etmek için:
1
2
In [37]: df.iloc[1, 1]
Out[37]: -0.17321464905330858
Bir skalere hızlı erişim elde etmek için (önceki yönteme eşdeğer):
1
2
In [38]: df.iat[1, 1]
Out[38]: -0.17321464905330858
Boole indeksleme
Nerede satır seçin df.A daha büyük 0.
1
2
3
4
5
6
In [39]: df[df["A"] > 0]
Out[39]:
A B C D
2013-01-01 0.469112 -0.282863 -1.509059 -1.135632
2013-01-02 1.212112 -0.173215 0.119209 -1.044236
2013-01-04 0.721555 -0.706771 -1.039575 0.271860
Bir değerden seçim yapma DataFrame bir boole durumunun karşılandığı yer:
1
2
3
4
5
6
7
8
9
In [40]: df[df > 0]
Out[40]:
A B C D
2013-01-01 0.469112 NaN NaN NaN
2013-01-02 1.212112 NaN 0.119209 NaN
2013-01-03 NaN NaN NaN 1.071804
2013-01-04 0.721555 NaN NaN 0.271860
2013-01-05 NaN 0.567020 0.276232 NaN
2013-01-06 NaN 0.113648 NaN 0.524988
kullanarak isin() filtreleme yöntemi:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
In [41]: df2 = df.copy()
In [42]: df2["E"] = ["one", "one", "two", "three", "four", "three"]
In [43]: df2
Out[43]:
A B C D E
2013-01-01 0.469112 -0.282863 -1.509059 -1.135632 one
2013-01-02 1.212112 -0.173215 0.119209 -1.044236 one
2013-01-03 -0.861849 -2.104569 -0.494929 1.071804 two
2013-01-04 0.721555 -0.706771 -1.039575 0.271860 three
2013-01-05 -0.424972 0.567020 0.276232 -1.087401 four
2013-01-06 -0.673690 0.113648 -1.478427 0.524988 three
In [44]: df2[df2["E"].isin(["two", "four"])]
Out[44]:
A B C D E
2013-01-03 -0.861849 -2.104569 -0.494929 1.071804 two
2013-01-05 -0.424972 0.567020 0.276232 -1.087401 four
Ayarlama
Yeni bir sütun ayarlamak, verileri dizinlere göre otomatik olarak hizalar:
1
2
3
4
5
6
7
8
9
10
11
12
13
In [45]: s1 = pd.Series([1, 2, 3, 4, 5, 6], index=pd.date_range("20130102", periods=6))
In [46]: s1
Out[46]:
2013-01-02 1
2013-01-03 2
2013-01-04 3
2013-01-05 4
2013-01-06 5
2013-01-07 6
Freq: D, dtype: int64
In [47]: df["F"] = s1
Değerleri etikete göre ayarlama:
1
In [48]: df.at[dates[0], "A"] = 0
Değerleri konuma göre ayarlama:
1
In [49]: df.iat[0, 1] = 0
NumPy dizisiyle atayarak ayarlama:
1
In [50]: df.loc[:, "D"] = np.array([5] * len(df))
Önceki ayar işlemlerinin sonucu:
1
2
3
4
5
6
7
8
9
In [51]: df
Out[51]:
A B C D F
2013-01-01 0.000000 0.000000 -1.509059 5.0 NaN
2013-01-02 1.212112 -0.173215 0.119209 5.0 1.0
2013-01-03 -0.861849 -2.104569 -0.494929 5.0 2.0
2013-01-04 0.721555 -0.706771 -1.039575 5.0 3.0
2013-01-05 -0.424972 0.567020 0.276232 5.0 4.0
2013-01-06 -0.673690 0.113648 -1.478427 5.0 5.0
A where ayarlı çalışma:
1
2
3
4
5
6
7
8
9
10
11
12
13
In [52]: df2 = df.copy()
In [53]: df2[df2 > 0] = -df2
In [54]: df2
Out[54]:
A B C D F
2013-01-01 0.000000 0.000000 -1.509059 -5.0 NaN
2013-01-02 -1.212112 -0.173215 -0.119209 -5.0 -1.0
2013-01-03 -0.861849 -2.104569 -0.494929 -5.0 -2.0
2013-01-04 -0.721555 -0.706771 -1.039575 -5.0 -3.0
2013-01-05 -0.424972 -0.567020 -0.276232 -5.0 -4.0
2013-01-06 -0.673690 -0.113648 -1.478427 -5.0 -5.0
Eksik veriler
NumPy veri türleri için, np.nan eksik verileri temsil eder. Tarafından varsayılan hesaplamalara dahil değildir. Görmek Eksik Veri bölümü.
Yeniden dizine ekleme, belirli bir eksendeki dizini değiştirmenize / eklemenize / silmenize olanak tanır. Bu verilerin bir kopyasını döndürür:
1
2
3
4
5
6
7
8
9
10
11
In [55]: df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ["E"])
In [56]: df1.loc[dates[0] : dates[1], "E"] = 1
In [57]: df1
Out[57]:
A B C D F E
2013-01-01 0.000000 0.000000 -1.509059 5.0 NaN 1.0
2013-01-02 1.212112 -0.173215 0.119209 5.0 1.0 1.0
2013-01-03 -0.861849 -2.104569 -0.494929 5.0 2.0 NaN
2013-01-04 0.721555 -0.706771 -1.039575 5.0 3.0 NaN
DataFrame.dropna()veri eksik olan satırları bırakır:
1
2
3
4
In [58]: df1.dropna(how="any")
Out[58]:
A B C D F E
2013-01-02 1.212112 -0.173215 0.119209 5.0 1.0 1.0
DataFrame.fillna()eksik verileri doldurur:
1
2
3
4
5
6
7
In [59]: df1.fillna(value=5)
Out[59]:
A B C D F E
2013-01-01 0.000000 0.000000 -1.509059 5.0 5.0 1.0
2013-01-02 1.212112 -0.173215 0.119209 5.0 1.0 1.0
2013-01-03 -0.861849 -2.104569 -0.494929 5.0 2.0 5.0
2013-01-04 0.721555 -0.706771 -1.039575 5.0 3.0 5.0
isna() değerlerin olduğu yerde boole maskesini alır nan:
1
2
3
4
5
6
7
In [60]: pd.isna(df1)
Out[60]:
A B C D F E
2013-01-01 False False False False True False
2013-01-02 False False False False False False
2013-01-03 False False False False False True
2013-01-04 False False False False False True
operasyonlar
Görmek İkili Ops hakkında temel bölüm.
İstatistikler
Genel olarak operasyonlar hariç eksik veri.
Her sütun için ortalama değeri hesaplayın:
1
2
3
4
5
6
7
8
In [61]: df.mean()
Out[61]:
A -0.004474
B -0.383981
C -0.687758
D 5.000000
F 3.000000
dtype: float64
Her satır için ortalama değeri hesaplayın:
1
2
3
4
5
6
7
8
9
In [62]: df.mean(axis=1)
Out[62]:
2013-01-01 0.872735
2013-01-02 1.431621
2013-01-03 0.707731
2013-01-04 1.395042
2013-01-05 1.883656
2013-01-06 1.592306
Freq: D, dtype: float64
Başka biriyle çalışma Series veya DataFrame farklı bir dizin veya sütunla sonucu dizin veya sütun etiketlerinin birleşimi ile hizalar. Ayrıca pandalar belirtilen boyut boyunca otomatik olarak yayın yapar ve hizalanmamış etiketleri np.nan.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
In [63]: s = pd.Series([1, 3, 5, np.nan, 6, 8], index=dates).shift(2)
In [64]: s
Out[64]:
2013-01-01 NaN
2013-01-02 NaN
2013-01-03 1.0
2013-01-04 3.0
2013-01-05 5.0
2013-01-06 NaN
Freq: D, dtype: float64
In [65]: df.sub(s, axis="index")
Out[65]:
A B C D F
2013-01-01 NaN NaN NaN NaN NaN
2013-01-02 NaN NaN NaN NaN NaN
2013-01-03 -1.861849 -3.104569 -1.494929 4.0 1.0
2013-01-04 -2.278445 -3.706771 -4.039575 2.0 0.0
2013-01-05 -5.424972 -4.432980 -4.723768 0.0 -1.0
2013-01-06 NaN NaN NaN NaN NaN
Kullanıcı tanımlı işlevler
DataFrame.agg() ve DataFrame.transform() kullanıcı tanımlı bir işlev uygular sonucunu sırasıyla azaltır veya yayınlar.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
In [66]: df.agg(lambda x: np.mean(x) * 5.6)
Out[66]:
A -0.025054
B -2.150294
C -3.851445
D 28.000000
F 16.800000
dtype: float64
In [67]: df.transform(lambda x: x * 101.2)
Out[67]:
A B C D F
2013-01-01 0.000000 0.000000 -152.716721 506.0 NaN
2013-01-02 122.665737 -17.529322 12.063922 506.0 101.2
2013-01-03 -87.219115 -212.982405 -50.086843 506.0 202.4
2013-01-04 73.021382 -71.525239 -105.204988 506.0 303.6
2013-01-05 -43.007200 57.382459 27.954680 506.0 404.8
2013-01-06 -68.177398 11.501219 -149.616767 506.0 506.0
Değer Sayıları
Daha fazlasını görmek için Histogramlama ve Ayrıklaştırma.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
In [68]: s = pd.Series(np.random.randint(0, 7, size=10))
In [69]: s
Out[69]:
0 4
1 2
2 1
3 2
4 6
5 4
6 4
7 6
8 4
9 4
dtype: int64
In [70]: s.value_counts()
Out[70]:
4 5
2 2
6 2
1 1
Name: count, dtype: int64
Dize Yöntemleri
Series bir dizi dize işleme yöntemi ile donatılmıştır. str dizinin her öğesinde, kod snippet aşağıda. Daha fazlasını görmek için Vektörleştirilmiş Dize Yöntemleri.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
In [71]: s = pd.Series(["A", "B", "C", "Aaba", "Baca", np.nan, "CABA", "dog", "cat"])
In [72]: s.str.lower()
Out[72]:
0 a
1 b
2 c
3 aaba
4 baca
5 NaN
6 caba
7 dog
8 cat
dtype: object
Birleştirmek
concat
pandalar kolayca bir araya gelmek için çeşitli olanaklar sunar Series ve DataFrame dizinler için çeşitli ayar mantığına sahip nesneler ve birleştirme / birleştirme türü durumunda ilişkisel cebir işlevselliği operasyonlar.
Görmek Birleştirme bölümü.
Birleştirici panda nesneleri ile birlikte satır olarak concat():
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
In [73]: df = pd.DataFrame(np.random.randn(10, 4))
In [74]: df
Out[74]:
0 1 2 3
0 -0.548702 1.467327 -1.015962 -0.483075
1 1.637550 -1.217659 -0.291519 -1.745505
2 -0.263952 0.991460 -0.919069 0.266046
3 -0.709661 1.669052 1.037882 -1.705775
4 -0.919854 -0.042379 1.247642 -0.009920
5 0.290213 0.495767 0.362949 1.548106
6 -1.131345 -0.089329 0.337863 -0.945867
7 -0.932132 1.956030 0.017587 -0.016692
8 -0.575247 0.254161 -1.143704 0.215897
9 1.193555 -0.077118 -0.408530 -0.862495
# break it into pieces
In [75]: pieces = [df[:3], df[3:7], df[7:]]
In [76]: pd.concat(pieces)
Out[76]:
0 1 2 3
0 -0.548702 1.467327 -1.015962 -0.483075
1 1.637550 -1.217659 -0.291519 -1.745505
2 -0.263952 0.991460 -0.919069 0.266046
3 -0.709661 1.669052 1.037882 -1.705775
4 -0.919854 -0.042379 1.247642 -0.009920
5 0.290213 0.495767 0.362949 1.548106
6 -1.131345 -0.089329 0.337863 -0.945867
7 -0.932132 1.956030 0.017587 -0.016692
8 -0.575247 0.254161 -1.143704 0.215897
9 1.193555 -0.077118 -0.408530 -0.862495
Not
Sütuna ekleme DataFrame nispeten hızlıdır. Ancak, bir satır bir kopya gerektirir ve pahalı olabilir. Geçmenizi öneririz önceden oluşturulmuş kayıt listesi DataFrame bunun yerine yapıcı bina a DataFrame kayıtları yinelemeli olarak ekleyerek.
Katıl
merge() belirli sütunlar boyunca SQL stili birleştirme türlerini etkinleştirir. Görmek Veritabanı stili birleştirme Bölüm.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
In [77]: left = pd.DataFrame({"key": ["foo", "foo"], "lval": [1, 2]})
In [78]: right = pd.DataFrame({"key": ["foo", "foo"], "rval": [4, 5]})
In [79]: left
Out[79]:
key lval
0 foo 1
1 foo 2
In [80]: right
Out[80]:
key rval
0 foo 4
1 foo 5
In [81]: pd.merge(left, right, on="key")
Out[81]:
key lval rval
0 foo 1 4
1 foo 1 5
2 foo 2 4
3 foo 2 5
merge()benzersiz tuşlarda:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
In [82]: left = pd.DataFrame({"key": ["foo", "bar"], "lval": [1, 2]})
In [83]: right = pd.DataFrame({"key": ["foo", "bar"], "rval": [4, 5]})
In [84]: left
Out[84]:
key lval
0 foo 1
1 bar 2
In [85]: right
Out[85]:
key rval
0 foo 4
1 bar 5
In [86]: pd.merge(left, right, on="key")
Out[86]:
key lval rval
0 foo 1 4
1 bar 2 5
gruplama
“grubuna göre ” ile, aşağıdakilerden bir veya daha fazlasını içeren bir işleme atıfta bulunuyoruz. aşağıdaki adımlar:
- bölme bazı kriterlere göre veriler gruplara ayrılır
- Uygulama her gruba bağımsız olarak bir işlev
- birleştirme sonuçlar bir veri yapısına dönüştürülür
Görmek Gruplama bölümü.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
In [87]: df = pd.DataFrame(
....: {
....: "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
....: "B": ["one", "one", "two", "three", "two", "two", "one", "three"],
....: "C": np.random.randn(8),
....: "D": np.random.randn(8),
....: }
....: )
....:
In [88]: df
Out[88]:
A B C D
0 foo one 1.346061 -1.577585
1 bar one 1.511763 0.396823
2 foo two 1.627081 -0.105381
3 bar three -0.990582 -0.532532
4 foo two -0.441652 1.453749
5 bar two 1.211526 1.208843
6 foo one 0.268520 -0.080952
7 foo three 0.024580 -0.264610
Bir sütun etiketine göre gruplama, sütun etiketlerini seçme ve ardından DataFrameGroupBy.sum() sonuçta ortaya çıkan fonksiyon gruplar:
1
2
3
4
5
6
In [89]: df.groupby("A")[["C", "D"]].sum()
Out[89]:
C D
A
bar 1.732707 1.073134
foo 2.824590 -0.574779
Birden çok sütun etiket formuna göre gruplandırma MultiIndex.
1
2
3
4
5
6
7
8
9
10
In [90]: df.groupby(["A", "B"]).sum()
Out[90]:
C D
A B
bar one 1.511763 0.396823
three -0.990582 -0.532532
two 1.211526 1.208843
foo one 1.614581 -1.658537
three 0.024580 -0.264610
two 1.185429 1.348368
yeniden şekillendirme
Bölümlere bakın Hiyerarşik İndeksleme ve yeniden şekillendirme.
yığın
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
In [91]: arrays = [
....: ["bar", "bar", "baz", "baz", "foo", "foo", "qux", "qux"],
....: ["one", "two", "one", "two", "one", "two", "one", "two"],
....: ]
....:
In [92]: index = pd.MultiIndex.from_arrays(arrays, names=["first", "second"])
In [93]: df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=["A", "B"])
In [94]: df2 = df[:4]
In [95]: df2
Out[95]:
A B
first second
bar one -0.727965 -0.589346
two 0.339969 -0.693205
baz one -0.339355 0.593616
two 0.884345 1.591431
. stack() “yöntemi ” öğesini DataFrame’in sütunlar:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
In [96]: stacked = df2.stack(future_stack=True)
In [97]: stacked
Out[97]:
first second
bar one A -0.727965
B -0.589346
two A 0.339969
B -0.693205
baz one A -0.339355
B 0.593616
two A 0.884345
B 1.591431
dtype: float64
“yığılmış ” Veri Çerçevesi veya Serisi ile ( MultiIndex olarak index), ters çalışması stack() dır-dir unstack(), varsayılan olarak son seviye:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
In [98]: stacked.unstack()
Out[98]:
A B
first second
bar one -0.727965 -0.589346
two 0.339969 -0.693205
baz one -0.339355 0.593616
two 0.884345 1.591431
In [99]: stacked.unstack(1)
Out[99]:
second one two
first
bar A -0.727965 0.339969
B -0.589346 -0.693205
baz A -0.339355 0.884345
B 0.593616 1.591431
In [100]: stacked.unstack(0)
Out[100]:
first bar baz
second
one A -0.727965 -0.339355
B -0.589346 0.593616
two A 0.339969 0.884345
B -0.693205 1.591431
Pivot tablolar
Aşağıdaki bölüme bakın Pivot Tabloları.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
In [101]: df = pd.DataFrame(
.....: {
.....: "A": ["one", "one", "two", "three"] * 3,
.....: "B": ["A", "B", "C"] * 4,
.....: "C": ["foo", "foo", "foo", "bar", "bar", "bar"] * 2,
.....: "D": np.random.randn(12),
.....: "E": np.random.randn(12),
.....: }
.....: )
.....:
In [102]: df
Out[102]:
A B C D E
0 one A foo -1.202872 0.047609
1 one B foo -1.814470 -0.136473
2 two C foo 1.018601 -0.561757
3 three A bar -0.595447 -1.623033
4 one B bar 1.395433 0.029399
5 one C bar -0.392670 -0.542108
6 two A foo 0.007207 0.282696
7 three B foo 1.928123 -0.087302
8 one C foo -0.055224 -1.575170
9 one A bar 2.395985 1.771208
10 two B bar 1.552825 0.816482
11 three C bar 0.166599 1.100230
pivot_table() pivots a DataFrame belirten values, index ve columns
1
2
3
4
5
6
7
8
9
10
11
12
13
In [103]: pd.pivot_table(df, values="D", index=["A", "B"], columns=["C"])
Out[103]:
C bar foo
A B
one A 2.395985 -1.202872
B 1.395433 -1.814470
C -0.392670 -0.055224
three A -0.595447 NaN
B NaN 1.928123
C 0.166599 NaN
two A NaN 0.007207
B 1.552825 NaN
C NaN 1.018601
Zaman serisi
pandalar performans için basit, güçlü ve verimli bir işlevselliğe sahiptir frekans dönüşümü sırasında yeniden örnekleme işlemleri (örneğin, ikinci olarak dönüştürme 5 dakikalık verilere veri). Bu son derece yaygındır, ancak bunlarla sınırlı değildir, finansal uygulamalar. Görmek Zaman Serisi bölümü.
1
2
3
4
5
6
7
8
In [104]: rng = pd.date_range("1/1/2012", periods=100, freq="s")
In [105]: ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)
In [106]: ts.resample("5Min").sum()
Out[106]:
2012-01-01 24182
Freq: 5min, dtype: int64
Series.tz_localize()bir zaman serisini bir saat dilimine yerleştirir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
In [107]: rng = pd.date_range("3/6/2012 00:00", periods=5, freq="D")
In [108]: ts = pd.Series(np.random.randn(len(rng)), rng)
In [109]: ts
Out[109]:
2012-03-06 1.857704
2012-03-07 -1.193545
2012-03-08 0.677510
2012-03-09 -0.153931
2012-03-10 0.520091
Freq: D, dtype: float64
In [110]: ts_utc = ts.tz_localize("UTC")
In [111]: ts_utc
Out[111]:
2012-03-06 00:00:00+00:00 1.857704
2012-03-07 00:00:00+00:00 -1.193545
2012-03-08 00:00:00+00:00 0.677510
2012-03-09 00:00:00+00:00 -0.153931
2012-03-10 00:00:00+00:00 0.520091
Freq: D, dtype: float64
Series.tz_convert()saat dilimlerinin farkında olan zaman serilerini başka bir saat dilimine dönüştürür:
1
2
3
4
5
6
7
8
In [112]: ts_utc.tz_convert("US/Eastern")
Out[112]:
2012-03-05 19:00:00-05:00 1.857704
2012-03-06 19:00:00-05:00 -1.193545
2012-03-07 19:00:00-05:00 0.677510
2012-03-08 19:00:00-05:00 -0.153931
2012-03-09 19:00:00-05:00 0.520091
Freq: D, dtype: float64
Sabit olmayan bir süre ekleme (BusinessDay) bir zaman serisine:
1
2
3
4
5
6
7
8
9
10
11
In [113]: rng
Out[113]:
DatetimeIndex(['2012-03-06', '2012-03-07', '2012-03-08', '2012-03-09',
'2012-03-10'],
dtype='datetime64[ns]', freq='D')
In [114]: rng + pd.offsets.BusinessDay(5)
Out[114]:
DatetimeIndex(['2012-03-13', '2012-03-14', '2012-03-15', '2012-03-16',
'2012-03-16'],
dtype='datetime64[ns]', freq=None)
kategoriler
pandalar kategorik verileri DataFrame. Tam dokümanlar için, kategorik giriş ve API belgeleri.
1
2
3
4
In [115]: df = pd.DataFrame(
.....: {"id": [1, 2, 3, 4, 5, 6], "raw_grade": ["a", "b", "b", "a", "a", "e"]}
.....: )
.....:
Ham kaliteleri kategorik bir veri türüne dönüştürme:
1
2
3
4
5
6
7
8
9
10
11
12
In [116]: df["grade"] = df["raw_grade"].astype("category")
In [117]: df["grade"]
Out[117]:
0 a
1 b
2 b
3 a
4 a
5 e
Name: grade, dtype: category
Categories (3, object): ['a', 'b', 'e']
Kategorileri daha anlamlı adlarla yeniden adlandırın:
1
2
3
In [118]: new_categories = ["very good", "good", "very bad"]
In [119]: df["grade"] = df["grade"].cat.rename_categories(new_categories)
Kategorileri yeniden sıralayın ve eksik kategorileri aynı anda ekleyin (aşağıdaki yöntemler) Series.cat() yeni bir dönüş Series varsayılan olarak):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
In [120]: df["grade"] = df["grade"].cat.set_categories(
.....: ["very bad", "bad", "medium", "good", "very good"]
.....: )
.....:
In [121]: df["grade"]
Out[121]:
0 very good
1 good
2 good
3 very good
4 very good
5 very bad
Name: grade, dtype: category
Categories (5, object): ['very bad', 'bad', 'medium', 'good', 'very good']
Sıralama, sözcük sırasına göre değil, kategorilerdeki siparişe göre:
1
2
3
4
5
6
7
8
9
In [122]: df.sort_values(by="grade")
Out[122]:
id raw_grade grade
5 6 e very bad
1 2 b good
2 3 b good
0 1 a very good
3 4 a very good
4 5 a very good
Kategorik bir sütuna göre gruplandırma observed=False ayrıca boş kategorileri gösterir:
1
2
3
4
5
6
7
8
9
In [123]: df.groupby("grade", observed=False).size()
Out[123]:
grade
very bad 1
bad 0
medium 0
good 2
very good 3
dtype: int64
Çizim
Görmek Çizim dokümanlar.
Matplotlib API’sına referans vermek için standart kuralı kullanıyoruz:
1
2
3
In [124]: import matplotlib.pyplot as plt
In [125]: plt.close("all")
. plt.close yöntem kullanılır yakın bir şekil penceresi:
1
2
3
4
5
In [126]: ts = pd.Series(np.random.randn(1000), index=pd.date_range("1/1/2000", periods=1000))
In [127]: ts = ts.cumsum()
In [128]: ts.plot();
plot()tüm sütunları çizer:
1
2
3
4
5
6
7
8
9
10
11
12
In [129]: df = pd.DataFrame(
.....: np.random.randn(1000, 4), index=ts.index, columns=["A", "B", "C", "D"]
.....: )
.....:
In [130]: df = df.cumsum()
In [131]: plt.figure();
In [132]: df.plot();
In [133]: plt.legend(loc='best');
Verileri içe ve dışa aktarma
Görmek IO Araçları Bölüm.
CSV
Bir csv dosyasına yazma: kullanarak DataFrame.to_csv()
1
2
3
In [134]: df = pd.DataFrame(np.random.randint(0, 5, (10, 5)))
In [135]: df.to_csv("foo.csv")
Bir csv dosyasından okuma: kullanarak read_csv()
1
2
3
4
5
6
7
8
9
10
11
12
13
In [136]: pd.read_csv("foo.csv")
Out[136]:
Unnamed: 0 0 1 2 3 4
0 0 4 3 1 1 2
1 1 1 0 2 3 2
2 2 1 4 2 1 2
3 3 0 4 0 2 2
4 4 4 2 2 3 4
5 5 4 0 4 3 1
6 6 2 1 2 0 3
7 7 4 0 4 4 4
8 8 4 4 1 0 1
9 9 0 4 3 0 3
Parke
Parke dosyasına yazma:
1
In [137]: df.to_parquet("foo.parquet")
Parke dosyasından okuma Mağaza kullanarak read_parquet():
1
2
3
4
5
6
7
8
9
10
11
12
13
In [138]: pd.read_parquet("foo.parquet")
Out[138]:
0 1 2 3 4
0 4 3 1 1 2
1 1 0 2 3 2
2 1 4 2 1 2
3 0 4 0 2 2
4 4 2 2 3 4
5 4 0 4 3 1
6 2 1 2 0 3
7 4 0 4 4 4
8 4 4 1 0 1
9 0 4 3 0 3
Excel
Okuma ve yazma Excel.
Kullanarak bir excel dosyasına yazma DataFrame.to_excel():
1
In [139]: df.to_excel("foo.xlsx", sheet_name="Sheet1")
Kullanarak bir excel dosyasından okuma read_excel():
1
2
3
4
5
6
7
8
9
10
11
12
13
In [140]: pd.read_excel("foo.xlsx", "Sheet1", index_col=None, na_values=["NA"])
Out[140]:
Unnamed: 0 0 1 2 3 4
0 0 4 3 1 1 2
1 1 1 0 2 3 2
2 2 1 4 2 1 2
3 3 0 4 0 2 2
4 4 4 2 2 3 4
5 5 4 0 4 3 1
6 6 2 1 2 0 3
7 7 4 0 4 4 4
8 8 4 4 1 0 1
9 9 0 4 3 0 3
Gotchas
Bir boole işlemi yapmaya çalışıyorsanız, Series veya DataFrame aşağıdaki gibi bir istisna görebilirsiniz:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
In [141]: if pd.Series([False, True, False]):
.....: print("I was true")
.....:
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-141-b27eb9c1dfc0> in ?()
----> 1 if pd.Series([False, True, False]):
2 print("I was true")
~/work/pandas/pandas/pandas/core/generic.py in ?(self)
1575 @final
1576 def __nonzero__(self) -> NoReturn:
-> 1577 raise ValueError(
1578 f"The truth value of a {type(self).__name__} is ambiguous. "
1579 "Use a.empty, a.bool(), a.item(), a.any() or a.all()."
1580 )
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
Görmek karşılaştırmalar ve Gotchas bir açıklama ve ne yapılması gerektiği.
Pandas Pivot Tabloları: Detaylı Açıklama
Pandas’ta pivot tabloları oluşturmak için pivot_table() fonksiyonu kullanılır. Bu fonksiyon, bir veya daha fazla sütunu indeks (satır), bir veya daha fazla sütunu sütun olarak kullanarak, diğer sütunlardaki verileri belirli bir toplama fonksiyonuyla özetler.
Pivot Tablo Nedir?
Bir pivot tablo, genellikle uzun (tidy) formattaki veriyi daha geniş (wide) formata dönüştürerek, belirli kategorilerdeki (gruplar) verilerin özet istatistiklerini (toplam, ortalama, sayım vb.) gösterir. Bu sayede, farklı boyutlardaki veriler arasındaki ilişkileri ve kalıpları kolayca keşfedebilirsiniz.
Örnek Senaryo:
Bir satış veri setiniz olduğunu düşünün:
| Bölge | Ürün Türü | Miktar | Satış |
|---|---|---|---|
| Doğu | Elektronik | 5 | 1000 |
| Batı | Giyim | 10 | 500 |
| Doğu | Giyim | 3 | 150 |
| Kuzey | Elektronik | 8 | 1600 |
| Batı | Elektronik | 2 | 400 |
| Doğu | Giyim | 7 | 350 |
Bu veriden şu gibi sorulara yanıt arayabiliriz:
- Her bölgenin toplam satışı ne kadar?
- Her ürün türünün toplam satışı ne kadar?
- Her bölgedeki her ürün türünün toplam satışı ne kadar?
İşte burada pivot_table() devreye girer.
pivot_table() Fonksiyonunun Ana Argümanları
pd.pivot_table() fonksiyonunun temel argümanları şunlardır:
data: Pivot tablo oluşturulacak DataFrame.values: Özetlenecek (toplanacak) sütun(lar). Buradaki değerleraggfuncile işlenecektir.index: Pivot tablonun satır indeksi olacak sütun(lar). Benzersiz değerler her satır için bir kategori oluşturur. Birden fazla sütun verilirse, hiyerarşik (MultiIndex) bir indeks oluşturulur.columns: Pivot tablonun sütunları olacak sütun(lar). Benzersiz değerler her sütun için bir kategori oluşturur. Birden fazla sütun verilirse, hiyerarşik (MultiIndex) bir sütun oluşturulur.aggfunc: Değerleri toplamak için kullanılacak toplama fonksiyonu(lar). Varsayılan olarak'mean'(ortalama) kullanılır. Tek bir fonksiyon ('sum','count',np.meanvb.) veya bir fonksiyon listesi/sözlüğü verilebilir.fill_value: Toplama işleminden sonra eksik kalan (NaN) değerleri doldurmak için kullanılacak değer.margins:Trueolarak ayarlanırsa, satır ve sütun toplamlarını içeren ‘All’ etiketli satır ve sütunlar ekler.dropna:True(varsayılan) ise, tüm değerleriNaNolan sütunları/satırları dışarıda bırakır.
pivot_table() ile Örnekler
Yukarıdaki satış veri setini kullanarak örnekler yapalım:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
import pandas as pd
import numpy as np
# Örnek Veri Seti
data = {
'Bölge': ['Doğu', 'Batı', 'Doğu', 'Kuzey', 'Batı', 'Doğu', 'Kuzey'],
'Ürün Türü': ['Elektronik', 'Giyim', 'Giyim', 'Elektronik', 'Elektronik', 'Giyim', 'Giyim'],
'Miktar': [5, 10, 3, 8, 2, 7, 12],
'Satış': [1000, 500, 150, 1600, 400, 350, 600]
}
df = pd.DataFrame(data)
print("Orijinal DataFrame:\n", df)
print("\n--- Pandas Pivot Tablo Kullanımı ---")
# Örnek 1: Her Bölgenin Toplam Satışı (aggfunc=sum varsayılan değil, belirtilmeli)
# index='Bölge' ile satırları bölgelere göre grupla
# values='Satış' ile Satış sütununu özetle
# aggfunc='sum' ile toplamı al
pivot_1 = pd.pivot_table(df, index='Bölge', values='Satış', aggfunc='sum')
print("\n1. Her Bölgenin Toplam Satışı:\n", pivot_1)
# Çıktı:
# Satış
# Bölge
# Batı 900
# Doğu 1500
# Kuzey 2200
# Örnek 2: Her Ürün Türünün Ortalama Miktarı (varsayılan aggfunc='mean')
# index='Ürün Türü' ile satırları ürün türlerine göre grupla
# values='Miktar' ile Miktar sütununu özetle
pivot_2 = pd.pivot_table(df, index='Ürün Türü', values='Miktar') # aggfunc varsayılan 'mean'
print("\n2. Her Ürün Türünün Ortalama Miktarı:\n", pivot_2)
# Çıktı:
# Miktar
# Ürün Türü
# Elektronik 5.0
# Giyim 8.0
# Örnek 3: Bölge ve Ürün Türüne Göre Toplam Satış ve Ortalama Miktar
# index=['Bölge'] ile satırları bölgelere göre grupla
# columns=['Ürün Türü'] ile sütunları ürün türlerine göre grupla
# values=['Satış', 'Miktar'] ile hem Satış hem Miktar sütunlarını özetle
# aggfunc={'Satış': 'sum', 'Miktar': 'mean'} ile farklı sütunlara farklı fonksiyonlar
pivot_3 = pd.pivot_table(df,
index='Bölge',
columns='Ürün Türü',
values=['Satış', 'Miktar'],
aggfunc={'Satış': 'sum', 'Miktar': 'mean'},
fill_value=0) # NaN değerleri 0 ile doldur
print("\n3. Bölge ve Ürün Türüne Göre Toplam Satış ve Ortalama Miktar:\n", pivot_3)
# Çıktı:
# Miktar Satış
# Ürün Türü Elektronik Giyim Elektronik Giyim
# Bölge
# Batı 2.0 10.0 400 500
# Doğu 5.0 5.0 1000 500
# Kuzey 8.0 12.0 1600 600
# Örnek 4: Toplamlar (margins=True) ile pivot tablo
pivot_4 = pd.pivot_table(df,
index='Bölge',
columns='Ürün Türü',
values='Satış',
aggfunc='sum',
margins=True, # Satır ve sütun toplamlarını ekler
fill_value=0)
print("\n4. Toplamlar ile Bölge ve Ürün Türüne Göre Toplam Satış:\n", pivot_4)
# Çıktı:
# Ürün Türü Elektronik Giyim All
# Bölge
# Batı 400 500 900
# Doğu 1000 500 1500
# Kuzey 1600 600 2200
# All 3000 1600 4600
# Örnek 5: Farklı fonksiyonları tek bir sütun için uygulama
pivot_5 = pd.pivot_table(df,
index='Bölge',
values='Satış',
aggfunc=[np.sum, np.mean, np.max])
print("\n5. Bölgeye Göre Satış için birden fazla fonksiyon:\n", pivot_5)
# Çıktı:
# sum mean amax
# Bölge
# Batı 900 450.0 500
# Doğu 1500 500.0 1000
# Kuzey 2200 1100.0 1600
pivot_table() ve pivot() Arasındaki Fark
Pandas’ta bir de pivot() metodu bulunur. Temel fark şudur:
df.pivot(): Sadece tekil değerler içermesi garanti edilen bir sütunda (yani,indexvecolumnskombinasyonu için yalnızca birvaluesdeğeri olması gereken) “basit” bir pivot işlemi için kullanılır.aggfuncargümanı yoktur, yani toplama yapmaz. Eğer aynıindexvecolumnskombinasyonu için birden fazla değer varsa hata verir.pd.pivot_table(): Daha genel ve esnek bir araçtır. Belirtilenindexvecolumnskombinasyonları için birden fazla değer varsa, bunlarıaggfuncile toplar. Genelliklepivot()yerinepivot_table()tercih edilir çünkü daha yaygın veri senaryolarını destekler.
Özetle: pivot_table() daha çok “Excel pivot tablosu” deneyimini yansıtırken, pivot() daha çok “reshape” (yeniden şekillendirme) işlemine benzer.
Ne Zaman Pivot Tablo Kullanılır?
- Veri Özeti ve Raporlama: Büyük veri setlerinden hızlı özet istatistikler (toplamlar, ortalamalar, sayımlar) elde etmek için.
- İlişkileri Keşfetme: Farklı kategorik değişkenler arasındaki ilişkileri ve etkileşimleri görselleştirmek ve anlamak için. Örneğin, farklı ürün türlerinin farklı bölgelerdeki performansını karşılaştırmak.
- Veri Temizleme ve Hazırlık: Bazı makine öğrenimi modelleri için veriyi geniş formata dönüştürmek gerekebilir.
- Daha İyi Anlayış: Ham veriye göre daha anlaşılır ve yüksek seviyeli bir bakış açısı sunar.
Pandas’ın pivot_table() fonksiyonu, veri analizi ve raporlama sürecinizde size büyük kolaylık sağlayacaktır.