Python Pandas - Hızlı Kılavuz

Pandas, güçlü veri yapılarını kullanarak yüksek performanslı veri işleme ve analiz aracı sağlayan açık kaynaklı bir Python Kitaplığıdır. Pandas adı Panel Data - Çok Boyutlu verilerden bir Ekonometri kelimesinden türemiştir.

2008 yılında, geliştirici Wes McKinney, yüksek performansa ihtiyaç duyduğunda, veri analizi için esnek bir araç gerektiğinde pandalar geliştirmeye başladı.

Pandalardan önce, Python büyük ölçüde veri işleme ve hazırlama için kullanılıyordu. Veri analizine çok az katkısı oldu. Pandalar bu sorunu çözdü. Pandalar kullanarak, verilerin kaynağına bakılmaksızın verilerin işlenmesi ve analizinde beş tipik adımı gerçekleştirebiliriz - yükleme, hazırlama, işleme, modelleme ve analiz etme.

Pandalı Python, finans, ekonomi, İstatistik, analitik vb. Dahil olmak üzere akademik ve ticari alanlar dahil olmak üzere çok çeşitli alanlarda kullanılmaktadır.

Pandaların Temel Özellikleri

Varsayılan ve özelleştirilmiş indeksleme ile hızlı ve verimli DataFrame nesnesi.
Verileri farklı dosya biçimlerinden bellek içi veri nesnelerine yüklemek için araçlar.
Veri hizalama ve eksik verilerin entegre yönetimi.
Tarih setlerinin yeniden şekillendirilmesi ve özetlenmesi.
Büyük veri kümelerinin etiket tabanlı dilimlenmesi, indekslenmesi ve alt kümelenmesi.
Bir veri yapısındaki sütunlar silinebilir veya eklenebilir.
Toplama ve dönüşümler için verilere göre gruplayın.
Verilerin yüksek performanslı birleşmesi ve birleştirilmesi.
Zaman Serisi işlevselliği.

Standart Python dağıtımı Pandas modülüyle birlikte gelmez. Hafif bir alternatif, popüler Python paket yükleyicisini kullanarak NumPy'yi kurmaktır.pip.

pip install pandas

Anaconda Python paketini kurarsanız, Pandalar varsayılan olarak aşağıdakilerle birlikte kurulacaktır -

pencereler

Anaconda (kimden https://www.continuum.io) SciPy yığını için ücretsiz bir Python dağıtımıdır. Ayrıca Linux ve Mac için de mevcuttur.
Canopy (https://www.enthought.com/products/canopy/) ücretsiz ve Windows, Linux ve Mac için tam SciPy yığını ile ticari dağıtım olarak mevcuttur.
Python(x, y), Windows işletim sistemi için SciPy yığını ve Spyder IDE içeren ücretsiz bir Python dağıtımıdır. (Adresinden indirilebilirhttp://python-xy.github.io/)

Linux

İlgili Linux dağıtımlarının paket yöneticileri, SciPy yığınına bir veya daha fazla paket yüklemek için kullanılır.

For Ubuntu Users

sudo apt-get install python-numpy python-scipy python-matplotlibipythonipythonnotebook
python-pandas python-sympy python-nose

For Fedora Users

sudo yum install numpyscipy python-matplotlibipython python-pandas sympy
python-nose atlas-devel

Pandalar aşağıdaki üç veri yapısıyla ilgilenir -

Series
DataFrame
Panel

Bu veri yapıları, Numpy dizisi üzerine inşa edilmiştir, bu da hızlı oldukları anlamına gelir.

Boyut ve Açıklama

Bu veri yapılarını düşünmenin en iyi yolu, yüksek boyutlu veri yapısının, daha düşük boyutlu veri yapısının bir kabı olmasıdır. Örneğin, DataFrame bir Series kapsayıcısıdır, Panel bir DataFrame kapsayıcısıdır.

Veri yapısı	Boyutlar	Açıklama
Dizi	1	1D etiketli homojen dizi, boyut değiştirilemez.
Veri Çerçeveleri	2	Potansiyel olarak heterojen tipte sütunlara sahip genel 2D etiketli, boyutu değişebilir tablo yapısı.
Panel	3	Genel 3B etiketli, boyut değiştirilebilir dizi.

İki veya daha fazla boyutlu dizilerin oluşturulması ve kullanılması meşakkatli bir iştir, fonksiyonlar yazılırken veri setinin yönünü dikkate alma yükü kullanıcıya yüklenir. Ancak Pandalar veri yapılarını kullanarak kullanıcının zihinsel çabası azalır.

Örneğin, tablo verileriyle (DataFrame), anlamsal olarak daha yararlıdır. index (satırlar) ve columns Eksen 0 ve eksen 1 yerine.

Değişkenlik

Tüm Pandalar veri yapıları değiştirilebilir (değiştirilebilir) ve Seriler dışında tümü boyut değiştirilebilir. Seri boyut değiştirilemez.

Note- DataFrame yaygın olarak kullanılmaktadır ve en önemli veri yapılarından biridir. Panel çok daha az kullanılır.

Dizi

Seri, homojen verilere sahip tek boyutlu dizi benzeri bir yapıdır. Örneğin, aşağıdaki dizi 10, 23, 56,… tam sayılarının bir koleksiyonudur.

10	23	56	17	52	61	73	90	26	72

Anahtar noktaları

Homojen veriler
Boyut Değişmez
Değişken Verilerin Değerleri

Veri çerçevesi

DataFrame, heterojen verilere sahip iki boyutlu bir dizidir. Örneğin,

İsim	Yaş	Cinsiyet	Değerlendirme
Steve	32	Erkek	3.45
Lia	28	Kadın	4.6
Vin	45	Erkek	3.9
Katie	38	Kadın	2.78

Tablo, bir organizasyonun satış ekibinin verilerini genel performans derecelendirmeleriyle temsil eder. Veriler satırlar ve sütunlar halinde temsil edilir. Her sütun bir özelliği temsil eder ve her satır bir kişiyi temsil eder.

Sütunların Veri Türü

Dört sütunun veri türleri aşağıdaki gibidir -

Sütun	Tür
İsim	Dize
Yaş	Tamsayı
Cinsiyet	Dize
Değerlendirme	Yüzer

Anahtar noktaları

Heterojen veriler
Boyut Değişebilir
Veri Değişebilir

Panel

Panel, heterojen veriler içeren üç boyutlu bir veri yapısıdır. Paneli grafik olarak temsil etmek zordur. Ancak bir panel, DataFrame'in bir kapsayıcısı olarak gösterilebilir.

Anahtar noktaları

Heterojen veriler
Boyut Değişebilir
Veri Değişebilir

Seri, her türden veriyi (tamsayı, dize, kayan nokta, python nesneleri vb.) Tutabilen tek boyutlu etiketlenmiş bir dizidir. Eksen etiketleri toplu olarak indeks olarak adlandırılır.

pandalar serisi

Aşağıdaki kurucu kullanılarak bir Pandalar Serisi oluşturulabilir -

pandas.Series( data, index, dtype, copy)

Yapıcının parametreleri aşağıdaki gibidir -

Sr.No	Parametre ve Açıklama
1	data veriler ndarray, liste, sabitler gibi çeşitli biçimler alır
2	index Dizin değerleri benzersiz ve hashable olmalıdır, verilerle aynı uzunlukta olmalıdır. Varsayılannp.arange(n) hiçbir dizin geçilmezse.
3	dtype dtype, veri türü içindir. Yok ise, veri türü çıkarılacaktır
4	copy Verileri kopyalayın. Varsayılan Yanlış

Aşağıdaki gibi çeşitli girdiler kullanılarak bir dizi oluşturulabilir:

Array
Dict
Skaler değer veya sabit

Boş Seri Oluşturun

Oluşturulabilen temel bir seri, Boş Seridir.

Misal

#import the pandas library and aliasing as pd
import pandas as pd
s = pd.Series()
print s

Onun output aşağıdaki gibidir -

Series([], dtype: float64)

Ndarray'den bir Seri oluşturun

Veri bir ndarray ise, aktarılan dizin aynı uzunlukta olmalıdır. Hiçbir dizin geçilmezse, varsayılan olarak dizinrange(n) nerede n dizi uzunluğudur, yani [0,1,2,3…. range(len(array))-1].

örnek 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data)
print s

Onun output aşağıdaki gibidir -

0   a
1   b
2   c
3   d
dtype: object

Herhangi bir dizini geçmedik, bu nedenle varsayılan olarak 0 ile len(data)-1yani 0 ila 3.

Örnek 2

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data,index=[100,101,102,103])
print s

Onun output aşağıdaki gibidir -

100  a
101  b
102  c
103  d
dtype: object

İndeks değerlerini buraya ilettik. Artık çıktıda özelleştirilmiş indekslenmiş değerleri görebiliriz.

Dikteden bir dizi oluşturun

Bir dictgirdi olarak geçirilebilir ve herhangi bir dizin belirtilmezse, dizin oluşturmak için sözlük anahtarları sıralı bir sırada alınır. Eğerindex geçildiğinde, dizindeki etiketlere karşılık gelen verilerdeki değerler çıkarılır.

örnek 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print s

Onun output aşağıdaki gibidir -

a 0.0
b 1.0
c 2.0
dtype: float64

Observe - Dizin oluşturmak için sözlük anahtarları kullanılır.

Örnek 2

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data,index=['b','c','d','a'])
print s

Onun output aşağıdaki gibidir -

b 1.0
c 2.0
d NaN
a 0.0
dtype: float64

Observe - Dizin sırası korunur ve eksik eleman NaN (Sayı Değil) ile doldurulur.

Skalerden Seri Oluşturun

Veri skaler bir değer ise, bir indeks sağlanmalıdır. Değer, uzunluğuyla eşleşecek şekilde tekrarlanacaktır.index

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
s = pd.Series(5, index=[0, 1, 2, 3])
print s

Onun output aşağıdaki gibidir -

0  5
1  5
2  5
3  5
dtype: int64

Pozisyonlu Serilerden Verilere Erişim

Dizideki verilere, bir dizideki verilere benzer şekilde erişilebilir. ndarray.

örnek 1

İlk öğeyi geri alın. Bilindiği gibi, birinci eleman sıfır vasıtasında depolanır dizisi için sıfırdan başlar sayma ^inci pozisyon ve böylece.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the first element
print s[0]

Onun output aşağıdaki gibidir -

Örnek 2

Serideki ilk üç öğeyi alın. Önüne bir: girilirse, o dizinden sonraki tüm öğeler çıkarılacaktır. İki parametre (aralarında: aralarında) kullanılıyorsa, iki dizin arasındaki öğeler (durdurma dizini hariç)

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the first three element
print s[:3]

Onun output aşağıdaki gibidir -

a  1
b  2
c  3
dtype: int64

Örnek 3

Son üç öğeyi geri alın.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the last three element
print s[-3:]

Onun output aşağıdaki gibidir -

c  3
d  4
e  5
dtype: int64

Etiketi Kullanarak Verileri Alın (Dizin)

Seri, sabit boyuta benzer dict indeks etiketine göre değerleri alabilir ve ayarlayabilirsiniz.

örnek 1

Dizin etiketi değerini kullanarak tek bir öğeyi alın.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve a single element
print s['a']

Onun output aşağıdaki gibidir -

Örnek 2

Bir dizin etiketi değerleri listesi kullanarak birden çok öğeyi alın.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve multiple elements
print s[['a','c','d']]

Onun output aşağıdaki gibidir -

a  1
c  3
d  4
dtype: int64

Örnek 3

Bir etiket yoksa, bir istisna ortaya çıkar.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve multiple elements
print s['f']

Onun output aşağıdaki gibidir -

…
KeyError: 'f'

Bir Veri çerçevesi, iki boyutlu bir veri yapısıdır, yani veriler, satırlar ve sütunlar halinde tablo şeklinde hizalanır.

DataFrame'in Özellikleri

Potansiyel olarak sütunlar farklı türdendir
Boyut - Değişebilir
Etiketli eksenler (satırlar ve sütunlar)
Satır ve sütunlarda Aritmetik işlemler gerçekleştirebilir

Yapısı

Öğrenci verileriyle bir veri çerçevesi oluşturduğumuzu varsayalım.

Bunu bir SQL tablosu veya elektronik tablo veri temsili olarak düşünebilirsiniz.

pandas.DataFrame

Pandas DataFrame, aşağıdaki yapıcı kullanılarak oluşturulabilir -

pandas.DataFrame( data, index, columns, dtype, copy)

Yapıcının parametreleri aşağıdaki gibidir -

Sr.No	Parametre ve Açıklama
1	data veriler, ndarray, seri, harita, listeler, dikte, sabitler ve ayrıca başka bir DataFrame gibi çeşitli biçimleri alır.
2	index Satır etiketleri için, sonuçta ortaya çıkan çerçeve için kullanılacak Dizin, herhangi bir dizin geçilmezse İsteğe Bağlı Varsayılan np.arange (n) 'dir.
3	columns Sütun etiketleri için isteğe bağlı varsayılan sözdizimi - np.arange (n) şeklindedir. Bu yalnızca hiçbir dizin geçilmezse geçerlidir.
4	dtype Her sütunun veri türü.
5	copy Varsayılan False ise bu komut (veya her ne ise) verilerin kopyalanması için kullanılır.

DataFrame oluştur

Pandaların DataFrame'i aşağıdakiler gibi çeşitli girdiler kullanılarak oluşturulabilir:

Lists
dict
Series
Numpy ndarrays
Başka bir DataFrame

Bu bölümün sonraki bölümlerinde, bu girdileri kullanarak bir DataFrame'in nasıl oluşturulacağını göreceğiz.

Boş Bir DataFrame Oluşturun

Oluşturulabilen temel bir DataFrame, bir Boş Dataframe'dir.

Misal

#import the pandas library and aliasing as pd
import pandas as pd
df = pd.DataFrame()
print df

Onun output aşağıdaki gibidir -

Empty DataFrame
Columns: []
Index: []

Listelerden bir DataFrame oluşturun

DataFrame, tek bir liste veya bir liste listesi kullanılarak oluşturulabilir.

örnek 1

import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print df

Onun output aşağıdaki gibidir -

Örnek 2

import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print df

Onun output aşağıdaki gibidir -

Name      Age
0     Alex      10
1     Bob       12
2     Clarke    13

Örnek 3

import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print df

Onun output aşağıdaki gibidir -

Name     Age
0     Alex     10.0
1     Bob      12.0
2     Clarke   13.0

Note - Gözlemleyin, dtype parametresi, Yaş sütununun türünü kayan noktaya değiştirir.

Dict of ndarrays / Listelerden bir DataFrame oluşturun

Hepsi ndarraysaynı uzunlukta olmalıdır. Dizin geçilirse, dizinin uzunluğu dizilerin uzunluğuna eşit olmalıdır.

Hiçbir dizin geçilmezse, varsayılan olarak dizin aralık (n) olacaktır, burada n dizi uzunluğudur.

örnek 1

import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print df

Onun output aşağıdaki gibidir -

Age      Name
0     28        Tom
1     34       Jack
2     29      Steve
3     42      Ricky

Note- 0,1,2,3 değerlerine uyun. İşlev aralığı (n) kullanılarak her birine atanan varsayılan dizindir.

Örnek 2

Şimdi dizileri kullanarak indisli bir DataFrame oluşturalım.

import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print df

Onun output aşağıdaki gibidir -

Age    Name
rank1    28      Tom
rank2    34     Jack
rank3    29    Steve
rank4    42    Ricky

Note - Gözlemleyin, index parametresi her satıra bir dizin atar.

Dicts Listesinden bir DataFrame Oluşturun

Sözlük Listesi, bir DataFrame oluşturmak için girdi verileri olarak aktarılabilir. Sözlük tuşları varsayılan olarak sütun adları olarak alınır.

örnek 1

Aşağıdaki örnek, sözlüklerin bir listesini ileterek bir DataFrame'in nasıl oluşturulacağını gösterir.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print df

Onun output aşağıdaki gibidir -

a    b      c
0   1   2     NaN
1   5   10   20.0

Note - Eksik alanlara NaN (Sayı Değil) eklendiğini gözlemleyin.

Örnek 2

Aşağıdaki örnek, sözlüklerin bir listesini ve satır dizinlerini ileterek bir DataFrame'in nasıl oluşturulacağını gösterir.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print df

Onun output aşağıdaki gibidir -

a   b       c
first   1   2     NaN
second  5   10   20.0

Örnek 3

Aşağıdaki örnek, sözlükler, satır indeksleri ve sütun indeksleri listesiyle bir DataFrame'in nasıl oluşturulacağını gösterir.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]

#With two column indices, values same as dictionary keys
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])

#With two column indices with one index with other name
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print df1
print df2

Onun output aşağıdaki gibidir -

#df1 output
         a  b
first    1  2
second   5  10

#df2 output
         a  b1
first    1  NaN
second   5  NaN

Note- Dikkat edin, df2 DataFrame sözlük anahtarı dışında bir sütun indeksi ile oluşturulur; böylece, NaN'leri yerine ekledi. Oysa df1, sözlük anahtarlarıyla aynı sütun indisleri ile oluşturulur, bu nedenle NaN eklenir.

Dict of Series'den bir DataFrame oluşturun

Seriler Sözlüğü, bir DataFrame oluşturmak için aktarılabilir. Ortaya çıkan dizin, geçirilen tüm dizi dizinlerinin birleşimidir.

Misal

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df

Onun output aşağıdaki gibidir -

one    two
a     1.0    1
b     2.0    2
c     3.0    3
d     NaN    4

Note - Birinci seri için etiket olmadığını gözlemleyin ‘d’ geçti, ancak sonuçta d etiketinde NaN, NaN ile eklenir.

Şimdi anlayalım column selection, addition, ve deletion örnekler aracılığıyla.

Sütun Seçimi

Bunu DataFrame'den bir sütun seçerek anlayacağız.

Misal

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df ['one']

Onun output aşağıdaki gibidir -

a     1.0
b     2.0
c     3.0
d     NaN
Name: one, dtype: float64

Sütun Ekleme

Bunu, mevcut bir veri çerçevesine yeni bir sütun ekleyerek anlayacağız.

Misal

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)

# Adding a new column to an existing DataFrame object with column label by passing new series

print ("Adding a new column by passing as Series:")
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print df

print ("Adding a new column using the existing columns in DataFrame:")
df['four']=df['one']+df['three']

print df

Onun output aşağıdaki gibidir -

Adding a new column by passing as Series:
     one   two   three
a    1.0    1    10.0
b    2.0    2    20.0
c    3.0    3    30.0
d    NaN    4    NaN

Adding a new column using the existing columns in DataFrame:
      one   two   three    four
a     1.0    1    10.0     11.0
b     2.0    2    20.0     22.0
c     3.0    3    30.0     33.0
d     NaN    4     NaN     NaN

Sütun Silme

Sütunlar silinebilir veya çıkarılabilir; nasıl olduğunu anlamak için bir örnek alalım.

Misal

# Using the previous DataFrame, we will delete a column
# using del function
import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']), 
   'three' : pd.Series([10,20,30], index=['a','b','c'])}

df = pd.DataFrame(d)
print ("Our dataframe is:")
print df

# using del function
print ("Deleting the first column using DEL function:")
del df['one']
print df

# using pop function
print ("Deleting another column using POP function:")
df.pop('two')
print df

Onun output aşağıdaki gibidir -

Our dataframe is:
      one   three  two
a     1.0    10.0   1
b     2.0    20.0   2
c     3.0    30.0   3
d     NaN     NaN   4

Deleting the first column using DEL function:
      three    two
a     10.0     1
b     20.0     2
c     30.0     3
d     NaN      4

Deleting another column using POP function:
   three
a  10.0
b  20.0
c  30.0
d  NaN

Satır Seçimi, Toplama ve Silme

Şimdi satır seçimini, eklemeyi ve silmeyi örneklerle anlayacağız. Seçim kavramıyla başlayalım.

Etikete Göre Seçim

Satır etiketi bir satıra geçerek satırlar seçilebilir. loc işlevi.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df.loc['b']

Onun output aşağıdaki gibidir -

one 2.0
two 2.0
Name: b, dtype: float64

Sonuç, DataFrame'in sütun adları olarak etiketlere sahip bir seridir. Ve serinin Adı, birlikte alındığı etikettir.

Tamsayı konumuna göre seçim

Satırlar, tamsayı konumu bir iloc işlevi.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df.iloc[2]

Onun output aşağıdaki gibidir -

one   3.0
two   3.0
Name: c, dtype: float64

Satırları Dilimle

':' Operatörü kullanılarak birden çok satır seçilebilir.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df[2:4]

Onun output aşağıdaki gibidir -

one  two
c  3.0    3
d  NaN    4

Satırların Eklenmesi

Kullanarak bir DataFrame'e yeni satırlar ekleyin appendişlevi. Bu işlev satırları sonuna ekleyecektir.

import pandas as pd

df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])

df = df.append(df2)
print df

Onun output aşağıdaki gibidir -

Satırların Silinmesi

DataFrame'den satırları silmek veya bırakmak için dizin etiketini kullanın. Etiket kopyalanırsa, birden çok satır atlanacaktır.

Yukarıdaki örnekte, etiketlerin çift olduğunu gözlemlerseniz. Bir etiket bırakalım ve bakalım kaç satır düşecek.

import pandas as pd

df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])

df = df.append(df2)

# Drop rows with label 0
df = df.drop(0)

print df

Onun output aşağıdaki gibidir -

a b
1 3 4
1 7 8

Yukarıdaki örnekte, bu ikisi aynı 0 etiketini içerdiğinden iki satır çıkarılmıştır.

Bir panel3B bir veri kabıdır. DönemPanel data ekonometriden türetilmiştir ve kısmen pandalar adından sorumludur - pan(el)-da(ta)-s.

3 eksenin adlarının, panel verilerini içeren işlemleri açıklamak için anlamsal bir anlam vermesi amaçlanmıştır. Onlar -

items - eksen 0, her öğe içinde bulunan bir DataFrame'e karşılık gelir.
major_axis - eksen 1, her bir DataFrame'in indeksidir (satırları).
minor_axis - 2. eksen, her bir Veri Çerçevesinin sütunudur.

pandas.Panel ()

Aşağıdaki yapıcı kullanılarak bir Panel oluşturulabilir -

pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)

Yapıcının parametreleri aşağıdaki gibidir -

Parametre	Açıklama
veri	Veriler, ndarray, seri, harita, listeler, dikte, sabitler ve ayrıca başka bir DataFrame gibi çeşitli biçimler alır.
öğeler	eksen = 0
ana eksen	eksen = 1
minor_axis	eksen = 2
dtype	Her sütunun veri türü
kopya	Verileri kopyalayın. Varsayılan,false

Panel Oluştur

Bir Panel aşağıdakiler gibi birden çok yol kullanılarak oluşturulabilir:

Ndarrays'tan
DataFrame diktinden

3D ndarray'den

# creating an empty panel
import pandas as pd
import numpy as np

data = np.random.rand(2,4,5)
p = pd.Panel(data)
print p

Onun output aşağıdaki gibidir -

<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 5 (minor_axis)
Items axis: 0 to 1
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 4

Note - Boş panelin ve yukarıdaki panelin boyutlarına dikkat edin, tüm nesneler farklıdır.

DataFrame Nesnelerinin diktesinden

#creating an empty panel
import pandas as pd
import numpy as np

data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p

Onun output aşağıdaki gibidir -

Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2

Boş Panel Oluşturun

Panel yapıcısı kullanılarak aşağıdaki gibi boş bir panel oluşturulabilir -

#creating an empty panel
import pandas as pd
p = pd.Panel()
print p

Onun output aşağıdaki gibidir -

<class 'pandas.core.panel.Panel'>
Dimensions: 0 (items) x 0 (major_axis) x 0 (minor_axis)
Items axis: None
Major_axis axis: None
Minor_axis axis: None

Panelden Verileri Seçme

Panelden verileri seçin -

Items
Major_axis
Minor_axis

Öğeleri Kullanma

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p['Item1']

Onun output aşağıdaki gibidir -

0          1          2
0    0.488224  -0.128637   0.930817
1    0.417497   0.896681   0.576657
2   -2.775266   0.571668   0.290082
3   -0.400538  -0.144234   1.110535

İki öğemiz var ve item1'i aldık. Sonuç, 4 satırlı ve 3 sütunlu bir DataFrame'dir.Major_axis ve Minor_axis boyutlar.

Major_axis kullanma

Verilere yöntem kullanılarak erişilebilir panel.major_axis(index).

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.major_xs(1)

Onun output aşağıdaki gibidir -

Item1       Item2
0   0.417497    0.748412
1   0.896681   -0.557322
2   0.576657       NaN

Minor_axis kullanma

Verilere yöntem kullanılarak erişilebilir panel.minor_axis(index).

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.minor_xs(1)

Onun output aşağıdaki gibidir -

Item1       Item2
0   -0.128637   -1.047032
1    0.896681   -0.557322
2    0.571668    0.431953
3   -0.144234    1.302466

Note - Boyutlardaki değişiklikleri gözlemleyin.

Şimdiye kadar, üç Pandas Veri Yapısını ve bunları nasıl yaratacağımızı öğrendik. Gerçek zamanlı veri işlemedeki önemi nedeniyle büyük ölçüde DataFrame nesnelerine odaklanacağız ve ayrıca birkaç başka DataStructures'ı tartışacağız.

Seri Temel İşlevsellik

Sr.No.	Nitelik veya Yöntem ve Açıklama
1	axes Satır ekseni etiketlerinin bir listesini verir
2	dtype Nesnenin dtype değerini verir.
3	empty Seri boşsa True döndürür.
4	ndim Tanım 1'e göre temel alınan verilerin boyutlarının sayısını döndürür.
5	size Temel verilerdeki öğelerin sayısını döndürür.
6	values Seriyi ndarray olarak döndürür.
7	head() İlk n satırı döndürür.
8	tail() Son n satırı döndürür.

Şimdi bir Seri oluşturalım ve yukarıdaki tablodaki tüm özniteliklerin çalışmasını görelim.

Misal

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print s

Onun output aşağıdaki gibidir -

0   0.967853
1  -0.148368
2  -1.395906
3  -1.758394
dtype: float64

eksenler

Serinin etiketlerinin listesini döndürür.

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("The axes are:")
print s.axes

Onun output aşağıdaki gibidir -

The axes are:
[RangeIndex(start=0, stop=4, step=1)]

Yukarıdaki sonuç, 0'dan 5'e kadar olan değerler listesinin kompakt bir biçimidir, yani [0,1,2,3,4].

boş

Object'in boş olup olmadığını belirten Boolean değerini döndürür. True, nesnenin boş olduğunu gösterir.

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("Is the Object empty?")
print s.empty

Onun output aşağıdaki gibidir -

Is the Object empty?
False

ndim

Nesnenin boyutlarının sayısını verir. Tanım olarak, bir Seri 1B veri yapısıdır, bu nedenle

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s

print ("The dimensions of the object:")
print s.ndim

Onun output aşağıdaki gibidir -

0   0.175898
1   0.166197
2  -0.609712
3  -1.377000
dtype: float64

The dimensions of the object:
1

boyut

Serinin boyutunu (uzunluğunu) verir.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(2))
print s
print ("The size of the object:")
print s.size

Onun output aşağıdaki gibidir -

0   3.078058
1  -1.207803
dtype: float64

The size of the object:
2

değerler

Dizideki gerçek verileri bir dizi olarak döndürür.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s

print ("The actual data series is:")
print s.values

Onun output aşağıdaki gibidir -

0   1.787373
1  -0.605159
2   0.180477
3  -0.140922
dtype: float64

The actual data series is:
[ 1.78737302 -0.60515881 0.18047664 -0.1409218 ]

Kuyruk

Bir Series veya DataFrame nesnesinin küçük bir örneğini görüntülemek için head () ve tail () yöntemlerini kullanın.

head() ilkini döndürür nsatırlar (dizin değerlerini dikkate alın). Görüntülenecek varsayılan öğe sayısı beştir, ancak özel bir sayı iletebilirsiniz.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s

print ("The first two rows of the data series:")
print s.head(2)

Onun output aşağıdaki gibidir -

The original series is:
0   0.720876
1  -0.765898
2   0.479221
3  -0.139547
dtype: float64

The first two rows of the data series:
0   0.720876
1  -0.765898
dtype: float64

tail() sonuncuyu döndürür nsatırlar (dizin değerlerini dikkate alın). Görüntülenecek varsayılan öğe sayısı beştir, ancak özel bir sayı iletebilirsiniz.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s

print ("The last two rows of the data series:")
print s.tail(2)

Onun output aşağıdaki gibidir -

The original series is:
0 -0.655091
1 -0.881407
2 -0.608592
3 -2.341413
dtype: float64

The last two rows of the data series:
2 -0.608592
3 -2.341413
dtype: float64

DataFrame Temel İşlevselliği

Şimdi DataFrame Temel İşlevselliğinin ne olduğunu anlayalım. Aşağıdaki tablolar, DataFrame Temel İşlevselliğine yardımcı olan önemli öznitelikleri veya yöntemleri listeler.

Sr.No.	Nitelik veya Yöntem ve Açıklama
1	T Satırları ve sütunları ters çevirir.
2	axes Tek üye olarak satır ekseni etiketleri ve sütun ekseni etiketleri içeren bir liste döndürür.
3	dtypes Bu nesnedeki dtype'ları döndürür.
4	empty NDFrame tamamen boşsa doğrudur [öğe yok]; eksenlerden herhangi biri 0 uzunluğundaysa.
5	ndim Eksen sayısı / dizi boyutları.
6	shape DataFrame'in boyutluluğunu temsil eden bir demet döndürür.
7	size NDFrame'deki öğelerin sayısı.
8	values NDFrame'in numpy gösterimi.
9	head() İlk n satırı döndürür.
10	tail() Son n satırı döndürür.

Şimdi bir DataFrame oluşturalım ve yukarıda bahsedilen özelliklerin nasıl çalıştığını görelim.

Misal

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data series is:")
print df

Onun output aşağıdaki gibidir -

Our data series is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

T (Transpoze)

DataFrame'in devrikini döndürür. Satırlar ve sütunlar birbirinin yerine geçecektir.

import pandas as pd
import numpy as np
 
# Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

# Create a DataFrame
df = pd.DataFrame(d)
print ("The transpose of the data series is:")
print df.T

Onun output aşağıdaki gibidir -

The transpose of the data series is:
         0     1       2      3      4      5       6
Age      25    26      25     23     30     29      23
Name     Tom   James   Ricky  Vin    Steve  Smith   Jack
Rating   4.23  3.24    3.98   2.56   3.2    4.6     3.8

eksenler

Satır ekseni etiketlerinin ve sütun ekseni etiketlerinin listesini döndürür.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Row axis labels and column axis labels are:")
print df.axes

Onun output aşağıdaki gibidir -

Row axis labels and column axis labels are:

[RangeIndex(start=0, stop=7, step=1), Index([u'Age', u'Name', u'Rating'],
dtype='object')]

tipler

Her sütunun veri türünü döndürür.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("The data types of each column are:")
print df.dtypes

Onun output aşağıdaki gibidir -

The data types of each column are:
Age     int64
Name    object
Rating  float64
dtype: object

boş

Object'in boş olup olmadığını belirten Boolean değerini döndürür; True, nesnenin boş olduğunu gösterir.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Is the object empty?")
print df.empty

Onun output aşağıdaki gibidir -

Is the object empty?
False

ndim

Nesnenin boyutlarının sayısını verir. DataFrame tanımı gereği 2B bir nesnedir.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The dimension of the object is:")
print df.ndim

Onun output aşağıdaki gibidir -

Our object is:
      Age    Name     Rating
0     25     Tom      4.23
1     26     James    3.24
2     25     Ricky    3.98
3     23     Vin      2.56
4     30     Steve    3.20
5     29     Smith    4.60
6     23     Jack     3.80

The dimension of the object is:
2

şekil

DataFrame'in boyutluluğunu temsil eden bir demet döndürür. Tuple (a, b), burada a satır sayısını temsil eder veb sütun sayısını temsil eder.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The shape of the object is:")
print df.shape

Onun output aşağıdaki gibidir -

Our object is:
   Age   Name    Rating
0  25    Tom     4.23
1  26    James   3.24
2  25    Ricky   3.98
3  23    Vin     2.56
4  30    Steve   3.20
5  29    Smith   4.60
6  23    Jack    3.80

The shape of the object is:
(7, 3)

boyut

DataFrame'deki öğelerin sayısını döndürür.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The total number of elements in our object is:")
print df.size

Onun output aşağıdaki gibidir -

Our object is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The total number of elements in our object is:
21

değerler

DataFrame'deki gerçek verileri bir NDarray.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The actual data in our data frame is:")
print df.values

Onun output aşağıdaki gibidir -

Our object is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80
The actual data in our data frame is:
[[25 'Tom' 4.23]
[26 'James' 3.24]
[25 'Ricky' 3.98]
[23 'Vin' 2.56]
[30 'Steve' 3.2]
[29 'Smith' 4.6]
[23 'Jack' 3.8]]

Kuyruk

Bir DataFrame nesnesinin küçük bir örneğini görüntülemek için, head() ve tail () yöntemleri. head() ilkini döndürür nsatırlar (dizin değerlerini dikkate alın). Görüntülenecek varsayılan öğe sayısı beştir, ancak özel bir sayı iletebilirsiniz.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The first two rows of the data frame is:")
print df.head(2)

Onun output aşağıdaki gibidir -

Our data frame is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The first two rows of the data frame is:
   Age   Name   Rating
0  25    Tom    4.23
1  26    James  3.24

tail() sonuncuyu döndürür nsatırlar (dizin değerlerini dikkate alın). Görüntülenecek varsayılan öğe sayısı beştir, ancak özel bir sayı iletebilirsiniz.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]), 
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The last two rows of the data frame is:")
print df.tail(2)

Onun output aşağıdaki gibidir -

Our data frame is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The last two rows of the data frame is:
    Age   Name    Rating
5   29    Smith    4.6
6   23    Jack     3.8

Çok sayıda yöntem, DataFrame üzerinde tanımlayıcı istatistikleri ve diğer ilgili işlemleri toplu olarak hesaplar. Bunların çoğu gibi toplamalarsum(), mean(), ama bazıları gibi sumsum(), aynı boyutta bir nesne üretin. Genel olarak konuşursak, bu yöntemler biraxisbağımsız değişken, tıpkı ndarray gibi . {toplam, std, ...}, ancak eksen ad veya tamsayı ile belirtilebilir

DataFrame - "dizin" (eksen = 0, varsayılan), "sütunlar" (eksen = 1)

Bir DataFrame oluşturalım ve bu nesneyi bu bölüm boyunca tüm işlemler için kullanalım.

Misal

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df

Onun output aşağıdaki gibidir -

Age  Name   Rating
0   25   Tom     4.23
1   26   James   3.24
2   25   Ricky   3.98
3   23   Vin     2.56
4   30   Steve   3.20
5   29   Smith   4.60
6   23   Jack    3.80
7   34   Lee     3.78
8   40   David   2.98
9   30   Gasper  4.80
10  51   Betina  4.10
11  46   Andres  3.65

toplam ()

İstenen eksen için değerlerin toplamını verir. Varsayılan olarak eksen dizindir (eksen = 0).

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.sum()

Onun output aşağıdaki gibidir -

Age                                                    382
Name     TomJamesRickyVinSteveSmithJackLeeDavidGasperBe...
Rating                                               44.92
dtype: object

Her bir sütun ayrı ayrı eklenir (Dizeler eklenir).

eksen = 1

Bu sözdizimi, çıktıyı aşağıda gösterildiği gibi verecektir.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
 
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum(1)

Onun output aşağıdaki gibidir -

0    29.23
1    29.24
2    28.98
3    25.56
4    33.20
5    33.60
6    26.80
7    37.78
8    42.98
9    34.80
10   55.10
11   49.65
dtype: float64

anlamına gelmek()

Ortalama değeri verir

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.mean()

Onun output aşağıdaki gibidir -

Age       31.833333
Rating     3.743333
dtype: float64

std ()

Sayısal sütunların Bressel standart sapmasını döndürür.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.std()

Onun output aşağıdaki gibidir -

Age       9.232682
Rating    0.661628
dtype: float64

Fonksiyonlar ve Açıklama

Şimdi Python Pandas'ta Betimleyici İstatistikler altındaki işlevleri anlayalım. Aşağıdaki tablo önemli işlevleri listelemektedir -

Sr.No.	Fonksiyon	Açıklama
1	Miktar()	Boş olmayan gözlemlerin sayısı
2	toplam ()	Değerlerin toplamı
3	anlamına gelmek()	Değerlerin Ortalaması
4	medyan()	Değerlerin Ortanca Değeri
5	mod ()	Değerlerin modu
6	std ()	Değerlerin Standart Sapması
7	dk ()	Minimum değer
8	max ()	Maksimum değer
9	abs ()	Mutlak değer
10	prod ()	Değerlerin Çarpımı
11	cumsum ()	Kümülatif Toplam
12	cumprod ()	Kümülatif Ürün

Note- DataFrame Heterojen bir veri yapısı olduğundan. Genel işlemler tüm işlevlerle çalışmaz.

Gibi işlevler sum(), cumsum()hem sayısal hem de karakter (veya) dizisi veri öğeleriyle hatasız çalışır. Rağmenn pratikte, karakter kümelemeleri asla genel olarak kullanılmaz, bu işlevler herhangi bir istisna atmaz.
Gibi işlevler abs(), cumprod() DataFrame karakter veya dize verisi içerdiğinde istisna atar çünkü bu tür işlemler gerçekleştirilemez.

Verileri Özetleme

describe() işlevi, DataFrame sütunlarıyla ilgili istatistiklerin bir özetini hesaplar.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.describe()

Onun output aşağıdaki gibidir -

Age         Rating
count    12.000000      12.000000
mean     31.833333       3.743333
std       9.232682       0.661628
min      23.000000       2.560000
25%      25.000000       3.230000
50%      29.500000       3.790000
75%      35.500000       4.132500
max      51.000000       4.800000

Bu işlev, mean, std ve IQRdeğerler. Ve işlev, karakter sütunlarını hariç tutar ve sayısal sütunlarla ilgili özet verir.'include'özetleme için hangi sütunların dikkate alınması gerektiğine ilişkin gerekli bilgileri iletmek için kullanılan argümandır. Değerler listesini alır; varsayılan olarak 'sayı'.

object - Dize sütunlarını özetler
number - Sayısal sütunları özetler
all - Tüm sütunları birlikte özetler (Liste değeri olarak geçmemelidir)

Şimdi, programda aşağıdaki ifadeyi kullanın ve çıktıyı kontrol edin -

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.describe(include=['object'])

Onun output aşağıdaki gibidir -

Name
count       12
unique      12
top      Ricky
freq         1

Şimdi, aşağıdaki ifadeyi kullanın ve çıktıyı kontrol edin -

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df. describe(include='all')

Onun output aşağıdaki gibidir -

Age          Name       Rating
count   12.000000        12    12.000000
unique        NaN        12          NaN
top           NaN     Ricky          NaN
freq          NaN         1          NaN
mean    31.833333       NaN     3.743333
std      9.232682       NaN     0.661628
min     23.000000       NaN     2.560000
25%     25.000000       NaN     3.230000
50%     29.500000       NaN     3.790000
75%     35.500000       NaN     4.132500
max     51.000000       NaN     4.800000

Kendinizin veya başka bir kitaplığınızın işlevlerini Pandas nesnelerine uygulamak için, üç önemli yöntemin farkında olmalısınız. Yöntemler aşağıda tartışılmıştır. Kullanılacak uygun yöntem, işlevinizin tüm DataFrame üzerinde, satır veya sütun bazında veya öğe bazında çalışıp çalışmayacağına bağlıdır.

Tablo bilge İşlev Uygulama: boru ()
Satır veya Sütun Bilge İşlev Uygulaması: uygula ()
Element wise Function Uygulaması: applymap ()

Masa Üstü İşlev Uygulaması

Özel işlemler, işlevi ve uygun sayıda parametreyi boru bağımsız değişkenleri olarak ileterek gerçekleştirilebilir. Böylece, tüm DataFrame üzerinde işlem gerçekleştirilir.

Örneğin, DataFrame'deki tüm öğelere 2 değeri ekleyin. Sonra,

toplayıcı işlevi

Toplayıcı işlevi, parametre olarak iki sayısal değer ekler ve toplamı döndürür.

def adder(ele1,ele2):
   return ele1+ele2

Şimdi DataFrame üzerinde işlem yapmak için özel işlevi kullanacağız.

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)

Tam programı görelim -

import pandas as pd
import numpy as np

def adder(ele1,ele2):
   return ele1+ele2

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)
print df.apply(np.mean)

Onun output aşağıdaki gibidir -

col1       col2       col3
0   2.176704   2.219691   1.509360
1   2.222378   2.422167   3.953921
2   2.241096   1.135424   2.696432
3   2.355763   0.376672   1.182570
4   2.308743   2.714767   2.130288

Satır veya Sütun Bilge Fonksiyon Uygulaması

Rasgele işlevler, bir DataFrame veya Panelin eksenleri boyunca, apply()tanımlayıcı istatistik yöntemleri gibi, isteğe bağlı bir eksen argümanı alan yöntem. Varsayılan olarak işlem, her sütunu bir dizi benzeri alarak sütun bazında gerçekleştirilir.

örnek 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean)
print df.apply(np.mean)

Onun output aşağıdaki gibidir -

col1   -0.288022
col2    1.044839
col3   -0.187009
dtype: float64

Geçerek axis parametresinde işlemler satır bazında gerçekleştirilebilir.

Örnek 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean,axis=1)
print df.apply(np.mean)

Onun output aşağıdaki gibidir -

col1    0.034093
col2   -0.152672
col3   -0.229728
dtype: float64

Örnek 3

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(lambda x: x.max() - x.min())
print df.apply(np.mean)

Onun output aşağıdaki gibidir -

col1   -0.167413
col2   -0.370495
col3   -0.707631
dtype: float64

Element Wise Fonksiyon Uygulaması

Tüm işlevler vektörleştirilemez (ne başka bir dizi döndüren NumPy dizileri ne de herhangi bir değer), yöntemler applymap() DataFrame üzerinde ve analogously map() on Series, tek bir değer alıp tek bir değer döndüren herhangi bir Python işlevini kabul eder.

örnek 1

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])

# My custom function
df['col1'].map(lambda x:x*100)
print df.apply(np.mean)

Onun output aşağıdaki gibidir -

col1    0.480742
col2    0.454185
col3    0.266563
dtype: float64

Örnek 2

import pandas as pd
import numpy as np

# My custom function
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.applymap(lambda x:x*100)
print df.apply(np.mean)

Onun output aşağıdaki gibidir -

col1    0.395263
col2    0.204418
col3   -0.795188
dtype: float64

ReindexingDataFrame'in satır etiketlerini ve sütun etiketlerini değiştirir. Yeniden endekslemek , verileri belirli bir eksen boyunca belirli bir etiket kümesine uyacak şekilde uydurmak anlamına gelir.

İndeksleme yoluyla birden fazla işlem gerçekleştirilebilir -

Mevcut verileri yeni bir etiket kümesiyle eşleşecek şekilde yeniden sıralayın.
Etiket için hiçbir verinin bulunmadığı etiket konumlarına eksik değer (NA) işaretçileri ekleyin.

Misal

import pandas as pd
import numpy as np

N=20

df = pd.DataFrame({
   'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   'x': np.linspace(0,stop=N-1,num=N),
   'y': np.random.rand(N),
   'C': np.random.choice(['Low','Medium','High'],N).tolist(),
   'D': np.random.normal(100, 10, size=(N)).tolist()
})

#reindex the DataFrame
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])

print df_reindexed

Onun output aşağıdaki gibidir -

A    C     B
0  2016-01-01  Low   NaN
2  2016-01-03  High  NaN
5  2016-01-06  Low   NaN

Diğer Nesnelerle Hizalamak için Yeniden Dizin Oluştur

Bir nesneyi alıp eksenlerini başka bir nesneyle aynı şekilde etiketlemek için yeniden indekslemek isteyebilirsiniz. Aynısını anlamak için aşağıdaki örneği düşünün.

Misal

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])

df1 = df1.reindex_like(df2)
print df1

Onun output aşağıdaki gibidir -

col1         col2         col3
0    -2.467652    -1.211687    -0.391761
1    -0.287396     0.522350     0.562512
2    -0.255409    -0.483250     1.866258
3    -1.150467    -0.646493    -0.222462
4     0.152768    -2.056643     1.877233
5    -1.155997     1.528719    -1.343719
6    -1.015606    -1.245936    -0.295275

Note - İşte df1 DataFrame değiştirildi ve aşağıdaki gibi yeniden dizine alındı: df2. Sütun adları eşleşmelidir, aksi takdirde sütun etiketinin tamamı için NAN eklenir.

Yeniden İndeksleme Sırasında Doldurma

reindex() aşağıdaki gibi değerlerle doldurma yöntemi olan isteğe bağlı bir parametre yöntemini alır -

pad/ffill - Değerleri ileriye doğru doldurun
bfill/backfill - Değerleri geriye doğru doldurun
nearest - En yakın indeks değerlerinden doldurun

Misal

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])

# Padding NAN's
print df2.reindex_like(df1)

# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill:")
print df2.reindex_like(df1,method='ffill')

Onun output aşağıdaki gibidir -

col1        col2       col3
0    1.311620   -0.707176   0.599863
1   -0.423455   -0.700265   1.133371
2         NaN         NaN        NaN
3         NaN         NaN        NaN
4         NaN         NaN        NaN
5         NaN         NaN        NaN

Data Frame with Forward Fill:
         col1        col2        col3
0    1.311620   -0.707176    0.599863
1   -0.423455   -0.700265    1.133371
2   -0.423455   -0.700265    1.133371
3   -0.423455   -0.700265    1.133371
4   -0.423455   -0.700265    1.133371
5   -0.423455   -0.700265    1.133371

Note - Son dört sıra doldurulur.

Yeniden Dizine Ekleme Sırasında Doldurma Sınırları

Sınır argümanı, yeniden indeksleme sırasında doldurma üzerinde ek kontrol sağlar. Sınır, ardışık eşleşmelerin maksimum sayısını belirtir. Aynısını anlamak için aşağıdaki örneği ele alalım -

Misal

import pandas as pd
import numpy as np
 
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])

# Padding NAN's
print df2.reindex_like(df1)

# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill limiting to 1:")
print df2.reindex_like(df1,method='ffill',limit=1)

Onun output aşağıdaki gibidir -

col1        col2        col3
0    0.247784    2.128727    0.702576
1   -0.055713   -0.021732   -0.174577
2         NaN         NaN         NaN
3         NaN         NaN         NaN
4         NaN         NaN         NaN
5         NaN         NaN         NaN

Data Frame with Forward Fill limiting to 1:
         col1        col2        col3
0    0.247784    2.128727    0.702576
1   -0.055713   -0.021732   -0.174577
2   -0.055713   -0.021732   -0.174577
3         NaN         NaN         NaN
4         NaN         NaN         NaN
5         NaN         NaN         NaN

Note- Sadece 7. sıranın önceki 6. sıra tarafından doldurulduğuna dikkat edin. Ardından satırlar olduğu gibi bırakılır.

Yeniden adlandırılıyor

Rename () yöntemi, bazı eşlemelere (bir dikt veya Seri) veya rastgele bir işleve dayalı olarak bir ekseni yeniden etiketlemenizi sağlar.

Bunu anlamak için aşağıdaki örneği ele alalım -

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print df1

print ("After renaming the rows and columns:")
print df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},
index = {0 : 'apple', 1 : 'banana', 2 : 'durian'})

Onun output aşağıdaki gibidir -

col1        col2        col3
0    0.486791    0.105759    1.540122
1   -0.990237    1.007885   -0.217896
2   -0.483855   -1.645027   -1.194113
3   -0.122316    0.566277   -0.366028
4   -0.231524   -0.721172   -0.112007
5    0.438810    0.000225    0.435479

After renaming the rows and columns:
                c1          c2        col3
apple     0.486791    0.105759    1.540122
banana   -0.990237    1.007885   -0.217896
durian   -0.483855   -1.645027   -1.194113
3        -0.122316    0.566277   -0.366028
4        -0.231524   -0.721172   -0.112007
5         0.438810    0.000225    0.435479

Rename () yöntemi bir inplacevarsayılan olarak False olan ve temel alınan verileri kopyalayan adlandırılmış parametre. Geçmekinplace=True Verileri yerinde yeniden adlandırmak için.

Pandas nesneleri üzerindeki temel yinelemenin davranışı türe bağlıdır. Bir Seri üzerinde yineleme yapıldığında, dizi benzeri kabul edilir ve temel yineleme değerleri üretir. DataFrame ve Panel gibi diğer veri yapıları,dict-like üzerinde yineleme sözleşmesi keys nesnelerin.

Kısacası, temel yineleme (için i nesnede) üretir -

Series - değerler
DataFrame - sütun etiketleri
Panel - ürün etiketleri

Bir DataFrame'i Yineleme

Bir DataFrame'i yinelemek sütun adları verir. Aynısını anlamak için aşağıdaki örneği ele alalım.

import pandas as pd
import numpy as np
 
N=20
df = pd.DataFrame({
   'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   'x': np.linspace(0,stop=N-1,num=N),
   'y': np.random.rand(N),
   'C': np.random.choice(['Low','Medium','High'],N).tolist(),
   'D': np.random.normal(100, 10, size=(N)).tolist()
   })

for col in df:
   print col

Onun output aşağıdaki gibidir -

A
C
D
x
y

DataFrame'in satırları üzerinde yineleme yapmak için aşağıdaki işlevleri kullanabiliriz -

iteritems() - (anahtar, değer) çiftleri üzerinde yinelemek için
iterrows() - satırlar üzerinde (dizin, seri) çiftleri olarak yineleme
itertuples() - adlandırılmış çiftler olarak satırlar üzerinde yineleme

iteritems ()

Anahtar olarak her sütunun üzerinde, anahtar olarak etiketle değer çifti ve bir Seri nesnesi olarak sütun değeriyle birlikte yineler.

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
   print key,value

Onun output aşağıdaki gibidir -

col1 0    0.802390
1    0.324060
2    0.256811
3    0.839186
Name: col1, dtype: float64

col2 0    1.624313
1   -1.033582
2    1.796663
3    1.856277
Name: col2, dtype: float64

col3 0   -0.022142
1   -0.230820
2    1.160691
3   -0.830279
Name: col3, dtype: float64

Her sütunun bir Serideki anahtar / değer çifti olarak ayrı ayrı yinelendiğine dikkat edin.

yinelemeler ()

iterrows (), her satırdaki verileri içeren bir dizi ile birlikte her dizin değerini veren yineleyiciyi döndürür.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row_index,row in df.iterrows():
   print row_index,row

Onun output aşağıdaki gibidir -

0  col1    1.529759
   col2    0.762811
   col3   -0.634691
Name: 0, dtype: float64

1  col1   -0.944087
   col2    1.420919
   col3   -0.507895
Name: 1, dtype: float64
 
2  col1   -0.077287
   col2   -0.858556
   col3   -0.663385
Name: 2, dtype: float64
3  col1    -1.638578
   col2     0.059866
   col3     0.493482
Name: 3, dtype: float64

Note - Çünkü iterrows()satırlar üzerinde yineleyin, satır boyunca veri türünü korumaz. 0,1,2 satır indeksleridir ve col1, col2, col3 sütun indeksleridir.

yinelemeler ()

itertuples () yöntemi, DataFrame'deki her satır için adlandırılmış bir demet veren bir yineleyici döndürür. Demetin ilk öğesi, satırın karşılık gelen indeks değeri olurken, kalan değerler satır değerleridir.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row in df.itertuples():
    print row

Onun output aşağıdaki gibidir -

Pandas(Index=0, col1=1.5297586201375899, col2=0.76281127433814944, col3=-
0.6346908238310438)

Pandas(Index=1, col1=-0.94408735763808649, col2=1.4209186418359423, col3=-
0.50789517967096232)

Pandas(Index=2, col1=-0.07728664756791935, col2=-0.85855574139699076, col3=-
0.6633852507207626)

Pandas(Index=3, col1=0.65734942534106289, col2=-0.95057710432604969,
col3=0.80344487462316527)

Note- Yineleme sırasında herhangi bir nesneyi değiştirmeye çalışmayın. Yineleme, okumak içindir ve yineleyici, orijinal nesnenin bir kopyasını (bir görünüm) döndürür, böylece değişiklikler orijinal nesneye yansımayacaktır.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])

for index, row in df.iterrows():
   row['a'] = 10
print df

Onun output aşağıdaki gibidir -

col1       col2       col3
0  -1.739815   0.735595  -0.295589
1   0.635485   0.106803   1.527922
2  -0.939064   0.547095   0.038585
3  -1.016509  -0.116580  -0.523158

Gözlemleyin, hiçbir değişiklik yansıtılmadı.

Pandalar'da iki tür sıralama vardır. Onlar -

Etikete göre
Gerçek Değere Göre

Çıktısı olan bir örneği ele alalım.

import pandas as pd
import numpy as np

unsorted_df=pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns=['col2','col1'])
print unsorted_df

Onun output aşağıdaki gibidir -

col2       col1
1  -2.063177   0.537527
4   0.142932  -0.684884
6   0.012667  -0.389340
2  -0.548797   1.848743
3  -1.044160   0.837381
5   0.385605   1.300185
9   1.031425  -1.002967
8  -0.407374  -0.435142
0   2.237453  -1.067139
7  -1.445831  -1.701035

İçinde unsorted_df, labels ve valuessıralanmamış. Bakalım bunların nasıl sıralanabileceğini görelim.

Etikete Göre

Kullanmak sort_index()yönteminde, eksen bağımsız değişkenlerini ve sıralama sırasını ileterek DataFrame sıralanabilir. Varsayılan olarak sıralama, satır etiketlerinde artan sırada yapılır.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])

sorted_df=unsorted_df.sort_index()
print sorted_df

Onun output aşağıdaki gibidir -

col2       col1
0   0.208464   0.627037
1   0.641004   0.331352
2  -0.038067  -0.464730
3  -0.638456  -0.021466
4   0.014646  -0.737438
5  -0.290761  -1.669827
6  -0.797303  -0.018737
7   0.525753   1.628921
8  -0.567031   0.775951
9   0.060724  -0.322425

Sıralama Düzeni

Boolean değerini artan parametreye geçirerek, sıralamanın sırası kontrol edilebilir. Aynısını anlamak için aşağıdaki örneği ele alalım.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])

sorted_df = unsorted_df.sort_index(ascending=False)
print sorted_df

Onun output aşağıdaki gibidir -

col2        col1
9    0.825697    0.374463
8   -1.699509    0.510373
7   -0.581378    0.622958
6   -0.202951    0.954300
5   -1.289321   -1.551250
4    1.302561    0.851385
3   -0.157915   -0.388659
2   -1.222295    0.166609
1    0.584890   -0.291048
0    0.668444   -0.061294

Sütunları Sırala

0 veya 1 değerine sahip eksen bağımsız değişkenini ileterek, sütun etiketleri üzerinde sıralama yapılabilir. Varsayılan olarak, axis = 0, satıra göre sıralayın. Aynısını anlamak için aşağıdaki örneği ele alalım.

import pandas as pd
import numpy as np
 
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])
 
sorted_df=unsorted_df.sort_index(axis=1)

print sorted_df

Onun output aşağıdaki gibidir -

col1        col2
1   -0.291048    0.584890
4    0.851385    1.302561
6    0.954300   -0.202951
2    0.166609   -1.222295
3   -0.388659   -0.157915
5   -1.551250   -1.289321
9    0.374463    0.825697
8    0.510373   -1.699509
0   -0.061294    0.668444
7    0.622958   -0.581378

Değere Göre

Dizin sıralaması gibi, sort_values()değerlere göre sıralama yöntemidir. Değerlerin sıralanacağı DataFrame'in sütun adını kullanacak bir 'by' argümanını kabul eder.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
   sorted_df = unsorted_df.sort_values(by='col1')

print sorted_df

Onun output aşağıdaki gibidir -

col1  col2
1    1    3
2    1    2
3    1    4
0    2    1

Col1 değerlerinin sıralandığına ve ilgili col2 değerinin ve satır dizininin col1 ile birlikte değişeceğine dikkat edin. Böylece sıralanmamış görünüyorlar.

'by' argüman sütun değerlerinin bir listesini alır.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
   sorted_df = unsorted_df.sort_values(by=['col1','col2'])

print sorted_df

Onun output aşağıdaki gibidir -

Sıralama Algoritması

sort_values()algoritmayı birleştirme sıralaması, yığın sıralaması ve hızlı sıralama arasından seçmek için bir hüküm sağlar. Mergesort tek kararlı algoritmadır.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')

print sorted_df

Onun output aşağıdaki gibidir -

col1 col2
1    1    3
2    1    2
3    1    4
0    2    1

Bu bölümde, dizi işlemlerini temel Seri / Dizinimiz ile tartışacağız. Sonraki bölümlerde, bu dizi işlevlerini DataFrame'e nasıl uygulayacağımızı öğreneceğiz.

Pandas, dizi verileri üzerinde çalışmayı kolaylaştıran bir dizi dizi işlevi sağlar. En önemlisi, bu işlevler eksik / NaN değerlerini yok sayar (veya hariç tutar).

Neredeyse, bu yöntemlerin tümü Python dize işlevleriyle çalışır (bakın: https://docs.python.org/3/library/stdtypes.html#string-methods). Yani, Series Object'i String Object'e dönüştürün ve ardından işlemi gerçekleştirin.

Şimdi her işlemin nasıl performans gösterdiğini görelim.

Sr.No	İşlev ve Açıklama
1	lower() Seri / Dizindeki dizeleri küçük harfe dönüştürür.
2	upper() Seri / Dizindeki dizeleri büyük harfe dönüştürür.
3	len() Dize uzunluğunu () hesaplar.
4	strip() Seri / dizindeki her dizeden her iki taraftan beyaz boşlukları (satırsonu dahil) çıkarmaya yardımcı olur.
5	split(' ') Her dizeyi verilen desenle böler.
6	cat(sep=' ') Seri / dizin öğelerini verilen ayırıcıyla birleştirir.
7	get_dummies() DataFrame'i One-Hot Encoded değerlerle döndürür.
8	contains(pattern) Alt dizge öğede içeriyorsa, her öğe için bir Boolean değeri True, aksi takdirde False döndürür.
9	replace(a,b) Değeri değiştirir a değeri ile b.
10	repeat(value) Her bir öğeyi belirtilen sayıda yineler.
11	count(pattern) Her öğede desenin görünme sayısını döndürür.
12	startswith(pattern) Seri / Dizindeki öğe desenle başlıyorsa doğru döndürür.
13	endswith(pattern) Seri / Dizin içindeki öğe desenle biterse doğru döndürür.
14	find(pattern) Desenin ilk oluşumunun ilk konumunu döndürür.
15	findall(pattern) Modelin tüm oluşumlarının bir listesini döndürür.
16	swapcase Küçük / büyük harfleri değiştirir.
17	islower() Seri / Dizin içindeki her dizedeki tüm karakterlerin küçük harf olup olmadığını kontrol eder. Boolean döndürür
18	isupper() Seri / Dizin içindeki her dizedeki tüm karakterlerin büyük harf olup olmadığını kontrol eder. Boolean'ı döndürür.
19	isnumeric() Seri / Dizindeki her dizedeki tüm karakterlerin sayısal olup olmadığını kontrol eder. Boolean'ı döndürür.

Şimdi bir Seri oluşturalım ve yukarıdaki tüm fonksiyonların nasıl çalıştığını görelim.

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s

Onun output aşağıdaki gibidir -

0            Tom
1   William Rick
2           John
3        Alber@t
4            NaN
5           1234
6    Steve Smith
dtype: object

daha düşük ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s.str.lower()

Onun output aşağıdaki gibidir -

0            tom
1   william rick
2           john
3        alber@t
4            NaN
5           1234
6    steve smith
dtype: object

üst()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s.str.upper()

Onun output aşağıdaki gibidir -

0            TOM
1   WILLIAM RICK
2           JOHN
3        ALBER@T
4            NaN
5           1234
6    STEVE SMITH
dtype: object

len ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.len()

Onun output aşağıdaki gibidir -

0    3.0
1   12.0
2    4.0
3    7.0
4    NaN
5    4.0
6   10.0
dtype: float64

şerit ()

import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After Stripping:")
print s.str.strip()

Onun output aşağıdaki gibidir -

0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

After Stripping:
0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

bölünme (desen)

import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("Split Pattern:")
print s.str.split(' ')

Onun output aşağıdaki gibidir -

0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

Split Pattern:
0   [Tom, , , , , , , , , , ]
1   [, , , , , William, Rick]
2   [John]
3   [Alber@t]
dtype: object

kedi (sep = desen)

import pandas as pd
import numpy as np

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.cat(sep='_')

Onun output aşağıdaki gibidir -

Tom _ William Rick_John_Alber@t

get_dummies ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.get_dummies()

Onun output aşağıdaki gibidir -

William Rick   Alber@t   John   Tom
0             0         0      0     1
1             1         0      0     0
2             0         0      1     0
3             0         1      0     0

içerir ()

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.contains(' ')

Onun output aşağıdaki gibidir -

0   True
1   True
2   False
3   False
dtype: bool

değiştir (a, b)

import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After replacing @ with $:") print s.str.replace('@','$')

Onun output aşağıdaki gibidir -

0   Tom
1   William Rick
2   John
3   Alber@t
dtype: object

After replacing @ with $: 0 Tom 1 William Rick 2 John 3 Alber$t
dtype: object

tekrar (değer)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.repeat(2)

Onun output aşağıdaki gibidir -

0   Tom            Tom
1   William Rick   William Rick
2                  JohnJohn
3                  Alber@tAlber@t
dtype: object

sayım (desen)

import pandas as pd
 
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print ("The number of 'm's in each string:")
print s.str.count('m')

Onun output aşağıdaki gibidir -

The number of 'm's in each string:
0    1
1    1
2    0
3    0

startswith (desen)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print ("Strings that start with 'T':")
print s.str. startswith ('T')

Onun output aşağıdaki gibidir -

0  True
1  False
2  False
3  False
dtype: bool

endswith (desen)

import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that end with 't':")
print s.str.endswith('t')

Onun output aşağıdaki gibidir -

Strings that end with 't':
0  False
1  False
2  False
3  True
dtype: bool

bul (desen)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.find('e')

Onun output aşağıdaki gibidir -

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

"-1", öğede böyle bir model olmadığını gösterir.

findall (desen)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.findall('e')

Onun output aşağıdaki gibidir -

0 []
1 []
2 []
3 [e]
dtype: object

Boş liste ([]), öğede böyle bir model olmadığını gösterir.

takas kutusu ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.swapcase()

Onun output aşağıdaki gibidir -

0  tOM
1  wILLIAM rICK
2  jOHN
3  aLBER@T
dtype: object

islower ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.islower()

Onun output aşağıdaki gibidir -

0  False
1  False
2  False
3  False
dtype: bool

isupper ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])

print s.str.isupper()

Onun output aşağıdaki gibidir -

0  False
1  False
2  False
3  False
dtype: bool

isnumeric ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])

print s.str.isnumeric()

Onun output aşağıdaki gibidir -

0  False
1  False
2  False
3  False
dtype: bool

Pandalar, davranışının bazı yönlerini özelleştirmek için API sağlar, ekran çoğunlukla kullanılmaktadır.

API, beş ilgili işlevden oluşur. Onlar -

get_option()
set_option()
reset_option()
describe_option()
option_context()

Şimdi fonksiyonların nasıl çalıştığını anlayalım.

get_option (param)

get_option tek bir parametre alır ve aşağıdaki çıktıda verilen değeri döndürür -

display.max_rows

Varsayılan değer sayısını görüntüler. Yorumlayıcı bu değeri okur ve bu değere sahip satırları görüntülenecek üst sınır olarak görüntüler.

import pandas as pd
print pd.get_option("display.max_rows")

Onun output aşağıdaki gibidir -

display.max_columns

Varsayılan değer sayısını görüntüler. Yorumlayıcı bu değeri okur ve bu değere sahip satırları görüntülenecek üst sınır olarak görüntüler.

import pandas as pd
print pd.get_option("display.max_columns")

Onun output aşağıdaki gibidir -

Burada, 60 ve 20 varsayılan yapılandırma parametresi değerleridir.

set_option (param, değer)

set_option iki argüman alır ve değeri aşağıda gösterildiği gibi parametreye ayarlar -

display.max_rows

Kullanma set_option(), görüntülenecek varsayılan satır sayısını değiştirebiliriz.

import pandas as pd

pd.set_option("display.max_rows",80)

print pd.get_option("display.max_rows")

Onun output aşağıdaki gibidir -

display.max_columns

Kullanma set_option(), görüntülenecek varsayılan satır sayısını değiştirebiliriz.

import pandas as pd

pd.set_option("display.max_columns",30)

print pd.get_option("display.max_columns")

Onun output aşağıdaki gibidir -

reset_option (param)

reset_option bir bağımsız değişken alır ve değeri varsayılan değere geri ayarlar.

display.max_rows

Reset_option () kullanarak, değeri görüntülenecek varsayılan satır sayısına geri döndürebiliriz.

import pandas as pd

pd.reset_option("display.max_rows")
print pd.get_option("display.max_rows")

Onun output aşağıdaki gibidir -

define_option (param)

describe_option bağımsız değişkenin açıklamasını yazdırır.

display.max_rows

Reset_option () kullanarak, değeri görüntülenecek varsayılan satır sayısına geri döndürebiliriz.

import pandas as pd
pd.describe_option("display.max_rows")

Onun output aşağıdaki gibidir -

display.max_rows : int
   If max_rows is exceeded, switch to truncate view. Depending on
   'large_repr', objects are either centrally truncated or printed as
   a summary view. 'None' value means unlimited.

   In case python/IPython is running in a terminal and `large_repr`
   equals 'truncate' this can be set to 0 and pandas will auto-detect
   the height of the terminal and print a truncated object which fits
   the screen height. The IPython notebook, IPython qtconsole, or
   IDLE do not run in a terminal and hence it is not possible to do
   correct auto-detection.
   [default: 60] [currently: 60]

option_context ()

option_context bağlam yöneticisi, seçeneği ayarlamak için kullanılır with statementgeçici. Opsiyon değerleri otomatik olarak geri yüklenir.with block -

display.max_rows

Option_context () kullanarak değeri geçici olarak ayarlayabiliriz.

import pandas as pd
with pd.option_context("display.max_rows",10):
   print(pd.get_option("display.max_rows"))
   print(pd.get_option("display.max_rows"))

Onun output aşağıdaki gibidir -

10
10

Birinci ve ikinci baskı ifadeleri arasındaki farka bakın. İlk ifade, tarafından ayarlanan değeri yazdırıroption_context() içinde geçici olan with contextkendisi. Sonrawith contextikinci print deyimi, yapılandırılan değeri yazdırır.

Sık kullanılan Parametreler

Sr.No	Parametre ve Açıklama
1	display.max_rows Görüntülenecek maksimum satır sayısını görüntüler
2	2 display.max_columns Görüntülenecek maksimum sütun sayısını görüntüler
3	display.expand_frame_repr Sayfaları Uzatmak için DataFrame'leri görüntüler
4	display.max_colwidth Maksimum sütun genişliğini görüntüler
5	display.precision Ondalık sayıların hassasiyetini görüntüler

Bu bölümde, tarihin nasıl dilimlenip bölüneceğini ve genel olarak pandas nesnesinin alt kümesini nasıl alacağımızı tartışacağız.

Python ve NumPy indeksleme operatörleri "[]" ve öznitelik operatörü "." Çok çeşitli kullanım durumlarında Pandalar veri yapılarına hızlı ve kolay erişim sağlar. Bununla birlikte, erişilecek verilerin türü önceden bilinmediğinden, doğrudan standart operatörlerin kullanılması bazı optimizasyon sınırlarına sahiptir. Üretim kodu için, bu bölümde açıklanan optimize edilmiş pandalar veri erişim yöntemlerinden yararlanmanızı öneririz.

Pandalar artık üç tür Çok eksenli indekslemeyi destekliyor; üç tür aşağıdaki tabloda belirtilmiştir -

Sr.No	Endeksleme ve Açıklama
1	.loc() Etikete dayalı
2	.iloc() Tam sayıya dayalı
3	.ix() Hem Etiket hem de Tamsayı tabanlı

.loc ()

Pandalar, yalnızca sahip olmak için çeşitli yöntemler sağlar. label based indexing. Dilimleme sırasında başlangıç sınırı da dahil edilir. Tam sayılar geçerli etiketlerdir, ancak konumu değil etikete atıfta bulunurlar.

.loc() birden çok erişim yöntemine sahiptir -

Tek bir skaler etiket
Etiket listesi
Bir dilim nesnesi
Bir Boole dizisi

loc',' ile ayrılmış iki tek / liste / aralık operatörünü alır. Birincisi satırı, ikincisi sütunları gösterir.

örnek 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

#select all rows for a specific column
print df.loc[:,'A']

Onun output aşağıdaki gibidir -

a   0.391548
b  -0.070649
c  -0.317212
d  -2.162406
e   2.202797
f   0.613709
g   1.050559
h   1.122680
Name: A, dtype: float64

Örnek 2

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select all rows for multiple columns, say list[]
print df.loc[:,['A','C']]

Onun output aşağıdaki gibidir -

A           C
a    0.391548    0.745623
b   -0.070649    1.620406
c   -0.317212    1.448365
d   -2.162406   -0.873557
e    2.202797    0.528067
f    0.613709    0.286414
g    1.050559    0.216526
h    1.122680   -1.621420

Örnek 3

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select few rows for multiple columns, say list[]
print df.loc[['a','b','f','h'],['A','C']]

Onun output aşağıdaki gibidir -

A          C
a   0.391548   0.745623
b  -0.070649   1.620406
f   0.613709   0.286414
h   1.122680  -1.621420

Örnek 4

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select range of rows for all columns
print df.loc['a':'h']

Onun output aşağıdaki gibidir -

A           B          C          D
a    0.391548   -0.224297   0.745623   0.054301
b   -0.070649   -0.880130   1.620406   1.419743
c   -0.317212   -1.929698   1.448365   0.616899
d   -2.162406    0.614256  -0.873557   1.093958
e    2.202797   -2.315915   0.528067   0.612482
f    0.613709   -0.157674   0.286414  -0.500517
g    1.050559   -2.272099   0.216526   0.928449
h    1.122680    0.324368  -1.621420  -0.741470

Örnek 5

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# for getting values with a boolean array
print df.loc['a']>0

Onun output aşağıdaki gibidir -

A  False
B  True
C  False
D  False
Name: a, dtype: bool

.iloc ()

Pandalar, tamamen tamsayı tabanlı indeksleme elde etmek için çeşitli yöntemler sağlar. Python ve numpy gibi, bunlar0-based indeksleme.

Çeşitli erişim yöntemleri aşağıdaki gibidir -

Bir tam sayı
Tam sayıların listesi
Bir dizi değer

örnek 1

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# select all rows for a specific column
print df.iloc[:4]

Onun output aşağıdaki gibidir -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

Örnek 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Integer slicing
print df.iloc[:4]
print df.iloc[1:5, 2:4]

Onun output aşağıdaki gibidir -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

           C          D
1  -0.813012   0.631615
2   0.025070   0.230806
3   0.826977  -0.026251
4   1.423332   1.130568

Örnek 3

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Slicing through list of values
print df.iloc[[1, 3, 5], [1, 3]]
print df.iloc[1:3, :]
print df.iloc[:,1:3]

Onun output aşağıdaki gibidir -

B           D
1   0.890791    0.631615
3  -1.284314   -0.026251
5  -0.512888   -0.518930

           A           B           C           D
1  -0.685354    0.890791   -0.813012    0.631615
2  -0.783192   -0.531378    0.025070    0.230806

           B           C
0   0.256239   -1.270702
1   0.890791   -0.813012
2  -0.531378    0.025070
3  -1.284314    0.826977
4  -0.460729    1.423332
5  -0.512888    0.581409
6  -1.204853    0.098060
7  -0.947857    0.641358

.ix ()

Saf etiket tabanlı ve tamsayı tabanlı olmanın yanı sıra, Pandalar .ix () operatörünü kullanarak nesnenin seçilmesi ve alt kümelenmesi için karma bir yöntem sağlar.

örnek 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Integer slicing
print df.ix[:4]

Onun output aşağıdaki gibidir -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

Örnek 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Index slicing
print df.ix[:,'A']

Onun output aşağıdaki gibidir -

0   0.699435
1  -0.685354
2  -0.783192
3   0.539042
4  -1.044209
5  -1.415411
6   1.062095
7   0.994204
Name: A, dtype: float64

Notasyonların Kullanımı

Çoklu eksen indeksleme ile Pandas nesnesinden değerler almak aşağıdaki gösterimi kullanır -

Nesne	Dizin oluşturucular	Dönüş Tipi
Dizi	s.loc [dizinleyici]	Skaler değer
Veri çerçevesi	df.loc [row_index, col_index]	Seri nesnesi
Panel	p.loc [item_index, major_index, minor_index]	p.loc [item_index, major_index, minor_index]

Note − .iloc() & .ix() aynı indeksleme seçeneklerini ve Dönüş değerini uygular.

Şimdi her bir işlemin DataFrame nesnesinde nasıl gerçekleştirilebileceğini görelim. Temel indeksleme operatörünü '[]' kullanacağız -

örnek 1

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df['A']

Onun output aşağıdaki gibidir -

0  -0.478893
1   0.391931
2   0.336825
3  -1.055102
4  -0.165218
5  -0.328641
6   0.567721
7  -0.759399
Name: A, dtype: float64

Note - Bu sütunları seçmek için [] 'e bir değer listesi geçirebiliriz.

Örnek 2

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

print df[['A','B']]

Onun output aşağıdaki gibidir -

A           B
0  -0.478893   -0.606311
1   0.391931   -0.949025
2   0.336825    0.093717
3  -1.055102   -0.012944
4  -0.165218    1.550310
5  -0.328641   -0.226363
6   0.567721   -0.312585
7  -0.759399   -0.372696

Örnek 3

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df[2:2]

Onun output aşağıdaki gibidir -

Columns: [A, B, C, D]
Index: []

Öznitelik Erişimi

Sütunlar, özellik operatörü '.' Kullanılarak seçilebilir.

Misal

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

print df.A

Onun output aşağıdaki gibidir -

0   -0.478893
1    0.391931
2    0.336825
3   -1.055102
4   -0.165218
5   -0.328641
6    0.567721
7   -0.759399
Name: A, dtype: float64

İstatistiksel yöntemler, verilerin davranışının anlaşılmasına ve analiz edilmesine yardımcı olur. Şimdi Pandas nesnelerine uygulayabileceğimiz birkaç istatistiksel işlevi öğreneceğiz.

Yüzde değişimi

Seriler, DatFrame'ler ve Panel, hepsi işleve sahiptir pct_change(). Bu işlev, her öğeyi önceki öğesiyle karşılaştırır ve değişim yüzdesini hesaplar.

import pandas as pd
import numpy as np
s = pd.Series([1,2,3,4,5,4])
print s.pct_change()

df = pd.DataFrame(np.random.randn(5, 2))
print df.pct_change()

Onun output aşağıdaki gibidir -

0        NaN
1   1.000000
2   0.500000
3   0.333333
4   0.250000
5  -0.200000
dtype: float64

            0          1
0         NaN        NaN
1  -15.151902   0.174730
2  -0.746374   -1.449088
3  -3.582229   -3.165836
4   15.601150  -1.860434

Varsayılan olarak, pct_change()sütunlar üzerinde çalışır; aynı satırı akıllıca uygulamak istiyorsanız, o zaman kullanınaxis=1() argüman.

Kovaryans

Kovaryans, seri verilere uygulanır. Series nesnesi, seri nesneler arasındaki kovaryansı hesaplamak için bir yöntem koduna sahiptir. NA otomatik olarak hariç tutulacaktır.

Cov Serisi

import pandas as pd
import numpy as np
s1 = pd.Series(np.random.randn(10))
s2 = pd.Series(np.random.randn(10))
print s1.cov(s2)

Onun output aşağıdaki gibidir -

-0.12978405324

Bir DataFrame'e uygulandığında kovaryans yöntemi hesaplar cov tüm sütunlar arasında.

import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].cov(frame['b'])
print frame.cov()

Onun output aşağıdaki gibidir -

-0.58312921152741437

           a           b           c           d            e
a   1.780628   -0.583129   -0.185575    0.003679    -0.136558
b  -0.583129    1.297011    0.136530   -0.523719     0.251064
c  -0.185575    0.136530    0.915227   -0.053881    -0.058926
d   0.003679   -0.523719   -0.053881    1.521426    -0.487694
e  -0.136558    0.251064   -0.058926   -0.487694     0.960761

Note - cov arasında a ve b İlk ifadedeki sütun ve aynı DataFrame'de cov tarafından döndürülen değerdir.

Korelasyon

Korelasyon, herhangi iki değer dizisi (seri) arasındaki doğrusal ilişkiyi gösterir. Korelasyonu hesaplamak için pearson (varsayılan), spearman ve kendall gibi birden fazla yöntem vardır.

import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])

print frame['a'].corr(frame['b'])
print frame.corr()

Onun output aşağıdaki gibidir -

-0.383712785514

           a          b          c          d           e
a   1.000000  -0.383713  -0.145368   0.002235   -0.104405
b  -0.383713   1.000000   0.125311  -0.372821    0.224908
c  -0.145368   0.125311   1.000000  -0.045661   -0.062840
d   0.002235  -0.372821  -0.045661   1.000000   -0.403380
e  -0.104405   0.224908  -0.062840  -0.403380    1.000000

DataFrame'de sayısal olmayan herhangi bir sütun varsa, otomatik olarak hariç tutulur.

Veri Sıralaması

Veri Sıralaması, öğeler dizisindeki her öğe için sıralama üretir. Beraberlik durumunda, ortalama sırayı belirler.

import pandas as pd
import numpy as np

s = pd.Series(np.random.np.random.randn(5), index=list('abcde'))
s['d'] = s['b'] # so there's a tie
print s.rank()

Onun output aşağıdaki gibidir -

a  1.0
b  3.5
c  2.0
d  3.5
e  5.0
dtype: float64

Sıra isteğe bağlı olarak, varsayılan olarak doğru olan artan bir parametre alır; yanlış olduğunda, veriler ters sıralanır ve daha büyük değerlere daha küçük bir sıra atanır.

Rank, method parametresiyle belirtilen farklı bağ bozma yöntemlerini destekler -

average - bağlı grubun ortalama sıralaması
min - gruptaki en düşük rütbe
max - gruptaki en yüksek rütbe
first - dizide göründükleri sırayla atanan sıralar

Sayısal veriler üzerinde çalışmak için Pandalar, pencere istatistikleri için yuvarlanma, genişletme ve katlanarak hareket ettirme gibi birkaç değişken sağlar. Bunlar arasındasum, mean, median, variance, covariance, correlation, vb.

Şimdi bunların her birinin DataFrame nesnelerine nasıl uygulanabileceğini öğreneceğiz.

.rolling () Fonksiyonu

Bu işlev bir dizi veriye uygulanabilir. Belirtinwindow=n argüman ve bunun üzerine uygun istatistiksel işlevi uygulayın.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.rolling(window=3).mean()

Onun output aşağıdaki gibidir -

A           B           C           D
2000-01-01        NaN         NaN         NaN         NaN
2000-01-02        NaN         NaN         NaN         NaN
2000-01-03   0.434553   -0.667940   -1.051718   -0.826452
2000-01-04   0.628267   -0.047040   -0.287467   -0.161110
2000-01-05   0.398233    0.003517    0.099126   -0.405565
2000-01-06   0.641798    0.656184   -0.322728    0.428015
2000-01-07   0.188403    0.010913   -0.708645    0.160932
2000-01-08   0.188043   -0.253039   -0.818125   -0.108485
2000-01-09   0.682819   -0.606846   -0.178411   -0.404127
2000-01-10   0.688583    0.127786    0.513832   -1.067156

Note - Pencere boyutu 3 olduğundan, ilk iki öğe için boş değerler vardır ve üçüncüsünden değer, n, n-1 ve n-2elementler. Böylece yukarıda belirtildiği gibi çeşitli işlevleri de uygulayabiliriz.

.expanding () İşlevi

Bu işlev bir dizi veriye uygulanabilir. Belirtinmin_periods=n argüman ve bunun üzerine uygun istatistiksel işlevi uygulayın.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.expanding(min_periods=3).mean()

Onun output aşağıdaki gibidir -

A           B           C           D
2000-01-01        NaN         NaN         NaN         NaN
2000-01-02        NaN         NaN         NaN         NaN
2000-01-03   0.434553   -0.667940   -1.051718   -0.826452
2000-01-04   0.743328   -0.198015   -0.852462   -0.262547
2000-01-05   0.614776   -0.205649   -0.583641   -0.303254
2000-01-06   0.538175   -0.005878   -0.687223   -0.199219
2000-01-07   0.505503   -0.108475   -0.790826   -0.081056
2000-01-08   0.454751   -0.223420   -0.671572   -0.230215
2000-01-09   0.586390   -0.206201   -0.517619   -0.267521
2000-01-10   0.560427   -0.037597   -0.399429   -0.376886

.ewm () Fonksiyonu

ewmbir dizi veriye uygulanır. Com, span,halflifeargüman ve bunun üzerine uygun istatistiksel işlevi uygulayın. Ağırlıkları üssel olarak atar.

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.ewm(com=0.5).mean()

Onun output aşağıdaki gibidir -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   0.865131   -0.453626   -1.137961    0.058747
2000-01-03  -0.132245   -0.807671   -0.308308   -1.491002
2000-01-04   1.084036    0.555444   -0.272119    0.480111
2000-01-05   0.425682    0.025511    0.239162   -0.153290
2000-01-06   0.245094    0.671373   -0.725025    0.163310
2000-01-07   0.288030   -0.259337   -1.183515    0.473191
2000-01-08   0.162317   -0.771884   -0.285564   -0.692001
2000-01-09   1.147156   -0.302900    0.380851   -0.607976
2000-01-10   0.600216    0.885614    0.569808   -1.110113

Pencere fonksiyonları, eğriyi düzleştirerek verilerdeki eğilimleri grafik olarak bulmada büyük ölçüde kullanılır. Günlük verilerde çok fazla varyasyon varsa ve çok sayıda veri noktası mevcutsa, örnekleri almak ve çizim yapmak bir yöntemdir ve pencere hesaplamalarını uygulamak ve sonuçların üzerine grafiği çizmek başka bir yöntemdir. Bu yöntemlerle eğriyi veya eğilimi düzeltebiliriz.

Bir kez yuvarlanır, genişler ve ewm nesneler oluşturulur, veriler üzerinde toplamalar gerçekleştirmek için çeşitli yöntemler mevcuttur.

DataFrame'de Toplamaları Uygulama

Bir DataFrame oluşturalım ve üzerine toplamalar uygulayalım.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])

print df
r = df.rolling(window=3,min_periods=1)
print r

Onun output aşağıdaki gibidir -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   0.790670   -0.387854   -0.668132    0.267283
2000-01-03  -0.575523   -0.965025    0.060427   -2.179780
2000-01-04   1.669653    1.211759   -0.254695    1.429166
2000-01-05   0.100568   -0.236184    0.491646   -0.466081
2000-01-06   0.155172    0.992975   -1.205134    0.320958
2000-01-07   0.309468   -0.724053   -1.412446    0.627919
2000-01-08   0.099489   -1.028040    0.163206   -1.274331
2000-01-09   1.639500   -0.068443    0.714008   -0.565969
2000-01-10   0.326761    1.479841    0.664282   -1.361169

Rolling [window=3,min_periods=1,center=False,axis=0]

DataFrame'in tamamına bir işlev ileterek toplayabiliriz veya standart aracılığıyla bir sütun seçebiliriz get item yöntem.

Tüm Veri Çerçevesine Toplama Uygulama

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate(np.sum)

Onun output aşağıdaki gibidir -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469

                    A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469

Bir Veri Çerçevesinin Tek Sütununa Toplama Uygulama

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate(np.sum)

Onun output aşağıdaki gibidir -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
2000-01-01   1.088512
2000-01-02   1.879182
2000-01-03   1.303660
2000-01-04   1.884801
2000-01-05   1.194699
2000-01-06   1.925393
2000-01-07   0.565208
2000-01-08   0.564129
2000-01-09   2.048458
2000-01-10   2.065750
Freq: D, Name: A, dtype: float64

Bir DataFrame'in Birden Çok Sütununa Toplama Uygulama

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate(np.sum)

Onun output aşağıdaki gibidir -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                    A           B
2000-01-01   1.088512   -0.650942
2000-01-02   1.879182   -1.038796
2000-01-03   1.303660   -2.003821
2000-01-04   1.884801   -0.141119
2000-01-05   1.194699    0.010551
2000-01-06   1.925393    1.968551
2000-01-07   0.565208    0.032738
2000-01-08   0.564129   -0.759118
2000-01-09   2.048458   -1.820537
2000-01-10   2.065750    0.383357

Bir DataFrame'in Tek Bir Sütununa Birden Çok İşlev Uygulama

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate([np.sum,np.mean])

Onun output aşağıdaki gibidir -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                  sum       mean
2000-01-01   1.088512   1.088512
2000-01-02   1.879182   0.939591
2000-01-03   1.303660   0.434553
2000-01-04   1.884801   0.628267
2000-01-05   1.194699   0.398233
2000-01-06   1.925393   0.641798
2000-01-07   0.565208   0.188403
2000-01-08   0.564129   0.188043
2000-01-09   2.048458   0.682819
2000-01-10   2.065750   0.688583

Bir DataFrame'in Birden Çok Sütununa Birden Çok İşlev Uygulama

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate([np.sum,np.mean])

Onun output aşağıdaki gibidir -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                    A                      B
                  sum       mean         sum        mean
2000-01-01   1.088512   1.088512   -0.650942   -0.650942
2000-01-02   1.879182   0.939591   -1.038796   -0.519398
2000-01-03   1.303660   0.434553   -2.003821   -0.667940
2000-01-04   1.884801   0.628267   -0.141119   -0.047040
2000-01-05   1.194699   0.398233    0.010551    0.003517
2000-01-06   1.925393   0.641798    1.968551    0.656184
2000-01-07   0.565208   0.188403    0.032738    0.010913
2000-01-08   0.564129   0.188043   -0.759118   -0.253039
2000-01-09   2.048458   0.682819   -1.820537   -0.606846
2000-01-10   2.065750   0.688583    0.383357    0.127786

Veri Çerçevesinin Farklı Sütunlarına Farklı İşlevler Uygulama

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(3, 4),
   index = pd.date_range('1/1/2000', periods=3),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate({'A' : np.sum,'B' : np.mean})

Onun output aşağıdaki gibidir -

A          B          C         D
2000-01-01  -1.575749  -1.018105   0.317797  0.545081
2000-01-02  -0.164917  -1.361068   0.258240  1.113091
2000-01-03   1.258111   1.037941  -0.047487  0.867371
                    A          B
2000-01-01  -1.575749  -1.018105
2000-01-02  -1.740666  -1.189587
2000-01-03  -0.482555  -0.447078

Eksik veriler, gerçek hayat senaryolarında her zaman bir sorundur. Makine öğrenimi ve veri madenciliği gibi alanlar, eksik değerlerin neden olduğu düşük kaliteli veri nedeniyle model tahminlerinin doğruluğunda ciddi sorunlarla karşı karşıyadır. Bu alanlarda, eksik değer işleme, modellerini daha doğru ve geçerli kılmak için ana odak noktasıdır.

Veriler Ne Zaman ve Neden Kaçırılır?

Bir ürün için çevrimiçi bir anket düşünelim. Çoğu zaman insanlar kendileriyle ilgili tüm bilgileri paylaşmazlar. Çok az kişi deneyimlerini paylaşıyor, ancak ürünü ne kadar süre kullandıklarını bilmiyor; çok az kişi ürünü ne kadar süreyle kullandıklarını, deneyimlerini paylaşır ancak iletişim bilgilerini paylaşmaz. Bu nedenle, bir şekilde veya başka bir şekilde verilerin bir kısmı her zaman eksiktir ve bu gerçek zamanlı olarak çok yaygındır.

Şimdi Pandaları kullanarak eksik değerleri (örneğin NA veya NaN) nasıl ele alabileceğimize bakalım.

# import the pandas library
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df

Onun output aşağıdaki gibidir -

one        two      three
a   0.077988   0.476149   0.965836
b        NaN        NaN        NaN
c  -0.390208  -0.551605  -2.301950
d        NaN        NaN        NaN
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g        NaN        NaN        NaN
h   0.085100   0.532791   0.887415

Yeniden indekslemeyi kullanarak, eksik değerlere sahip bir DataFrame oluşturduk. Çıktıda,NaN anlamına geliyor Not a Number.

Eksik Değerleri Kontrol Edin

Eksik değerlerin tespit edilmesini kolaylaştırmak için (ve farklı dizi tipleri arasında) Pandalar, isnull() ve notnull() Series ve DataFrame nesnelerindeki yöntemler olan işlevler -

örnek 1

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].isnull()

Onun output aşağıdaki gibidir -

a  False
b  True
c  False
d  True
e  False
f  False
g  True
h  False
Name: one, dtype: bool

Örnek 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].notnull()

Onun output aşağıdaki gibidir -

a  True
b  False
c  True
d  False
e  True
f  True
g  False
h  True
Name: one, dtype: bool

Eksik Verilerle Hesaplamalar

Veriler toplanırken NA, Sıfır olarak değerlendirilecektir.
Verilerin tümü NA ise, sonuç NA olacaktır

örnek 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].sum()

Onun output aşağıdaki gibidir -

2.02357685917

Örnek 2

import pandas as pd
import numpy as np

df = pd.DataFrame(index=[0,1,2,3,4,5],columns=['one','two'])
print df['one'].sum()

Onun output aşağıdaki gibidir -

nan

Eksik Verileri Temizleme / Doldurma

Pandalar, eksik değerleri temizlemek için çeşitli yöntemler sunar. Fillna işlevi, aşağıdaki bölümlerde açıkladığımız gibi, NA değerlerini boş olmayan verilerle birkaç şekilde "doldurabilir".

NaN'yi Skaler Bir Değer ile Değiştirin

Aşağıdaki program "NaN" yi nasıl "0" ile değiştirebileceğinizi göstermektedir.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(3, 3), index=['a', 'c', 'e'],columns=['one',
'two', 'three'])

df = df.reindex(['a', 'b', 'c'])

print df
print ("NaN replaced with '0':")
print df.fillna(0)

Onun output aşağıdaki gibidir -

one        two     three
a  -0.576991  -0.741695  0.553172
b        NaN        NaN       NaN
c   0.744328  -1.735166  1.749580

NaN replaced with '0':
         one        two     three
a  -0.576991  -0.741695  0.553172
b   0.000000   0.000000  0.000000
c   0.744328  -1.735166  1.749580

Burada sıfır değeri ile dolduruyoruz; bunun yerine başka herhangi bir değerle de doldurabiliriz.

NA İleri ve Geri Doldurun

Yeniden İndeksleme Bölümünde tartışılan doldurma kavramlarını kullanarak eksik değerleri dolduracağız.

Sr.No	Yöntem ve Eylem
1	pad/fill Doldurma yöntemleri İleri
2	bfill/backfill Yöntemleri Geriye Doldur

örnek 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df.fillna(method='pad')

Onun output aşağıdaki gibidir -

one        two      three
a   0.077988   0.476149   0.965836
b   0.077988   0.476149   0.965836
c  -0.390208  -0.551605  -2.301950
d  -0.390208  -0.551605  -2.301950
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g  -0.930230  -0.670473   1.146615
h   0.085100   0.532791   0.887415

Örnek 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df.fillna(method='backfill')

Onun output aşağıdaki gibidir -

one        two      three
a   0.077988   0.476149   0.965836
b  -0.390208  -0.551605  -2.301950
c  -0.390208  -0.551605  -2.301950
d  -2.000303  -0.788201   1.510072
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g   0.085100   0.532791   0.887415
h   0.085100   0.532791   0.887415

Eksik Değerleri Bırak

Eksik değerleri hariç tutmak istiyorsanız, o zaman dropna ile birlikte işlev axisargüman. Varsayılan olarak, axis = 0, yani satır boyunca, yani bir satırdaki herhangi bir değer NA ise tüm satır hariç tutulur.

örnek 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna()

Onun output aşağıdaki gibidir -

one        two      three
a   0.077988   0.476149   0.965836
c  -0.390208  -0.551605  -2.301950
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
h   0.085100   0.532791   0.887415

Örnek 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna(axis=1)

Onun output aşağıdaki gibidir -

Empty DataFrame
Columns: [ ]
Index: [a, b, c, d, e, f, g, h]

Eksik (veya) Genel Değerleri Değiştirin

Çoğu zaman, genel bir değeri belirli bir değerle değiştirmemiz gerekir. Bunu değiştirme yöntemini uygulayarak başarabiliriz.

NA'yı skaler bir değerle değiştirmek, fillna() işlevi.

örnek 1

import pandas as pd
import numpy as np

df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})

print df.replace({1000:10,2000:60})

Onun output aşağıdaki gibidir -

one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

Örnek 2

import pandas as pd
import numpy as np

df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})
print df.replace({1000:10,2000:60})

Onun output aşağıdaki gibidir -

one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

Hiç groupbyişlem, orijinal nesne üzerinde aşağıdaki işlemlerden birini içerir. Onlar -

Splitting nesne
Applying bir işlev
Combining sonuçlar

Çoğu durumda, verileri kümelere ayırırız ve her alt kümeye bazı işlevler uygularız. Uygulama işlevinde aşağıdaki işlemleri gerçekleştirebiliriz -

Aggregation - bir özet istatistiği hesaplama
Transformation - gruba özgü bazı işlemler gerçekleştirin
Filtration - bazı koşullara sahip verilerin atılması

Şimdi bir DataFrame nesnesi oluşturalım ve üzerinde tüm işlemleri gerçekleştirelim -

#import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df

Onun output aşağıdaki gibidir -

Points   Rank     Team   Year
0      876      1   Riders   2014
1      789      2   Riders   2015
2      863      2   Devils   2014
3      673      3   Devils   2015
4      741      3    Kings   2014
5      812      4    kings   2015
6      756      1    Kings   2016
7      788      1    Kings   2017
8      694      2   Riders   2016
9      701      4   Royals   2014
10     804      1   Royals   2015
11     690      2   Riders   2017

Verileri Gruplara Böl

Pandalar nesnesi, nesnelerinden herhangi birine bölünebilir. Bir nesneyi bölmenin birden çok yolu vardır.

obj.groupby('key')
obj.groupby(['key1','key2'])
obj.groupby(key,axis=1)

Şimdi, gruplama nesnelerinin DataFrame nesnesine nasıl uygulanabileceğini görelim

Misal

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team')

Onun output aşağıdaki gibidir -

<pandas.core.groupby.DataFrameGroupBy object at 0x7fa46a977e50>

Grupları Görüntüle

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team').groups

Onun output aşağıdaki gibidir -

{'Kings': Int64Index([4, 6, 7],      dtype='int64'),
'Devils': Int64Index([2, 3],         dtype='int64'),
'Riders': Int64Index([0, 1, 8, 11],  dtype='int64'),
'Royals': Int64Index([9, 10],        dtype='int64'),
'kings' : Int64Index([5],            dtype='int64')}

Misal

Group by birden çok sütunlu -

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby(['Team','Year']).groups

Onun output aşağıdaki gibidir -

{('Kings', 2014): Int64Index([4], dtype='int64'),
 ('Royals', 2014): Int64Index([9], dtype='int64'),
 ('Riders', 2014): Int64Index([0], dtype='int64'),
 ('Riders', 2015): Int64Index([1], dtype='int64'),
 ('Kings', 2016): Int64Index([6], dtype='int64'),
 ('Riders', 2016): Int64Index([8], dtype='int64'),
 ('Riders', 2017): Int64Index([11], dtype='int64'),
 ('Devils', 2014): Int64Index([2], dtype='int64'),
 ('Devils', 2015): Int64Index([3], dtype='int64'),
 ('kings', 2015): Int64Index([5], dtype='int64'),
 ('Royals', 2015): Int64Index([10], dtype='int64'),
 ('Kings', 2017): Int64Index([7], dtype='int64')}

Gruplar arasında yineleme

İle groupby elimizdeki nesneyi, itertools.obj'ye benzer nesneyi yineleyebiliriz.

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')

for name,group in grouped:
   print name
   print group

Onun output aşağıdaki gibidir -

2014
   Points  Rank     Team   Year
0     876     1   Riders   2014
2     863     2   Devils   2014
4     741     3   Kings    2014
9     701     4   Royals   2014

2015
   Points  Rank     Team   Year
1     789     2   Riders   2015
3     673     3   Devils   2015
5     812     4    kings   2015
10    804     1   Royals   2015

2016
   Points  Rank     Team   Year
6     756     1    Kings   2016
8     694     2   Riders   2016

2017
   Points  Rank    Team   Year
7     788     1   Kings   2017
11    690     2  Riders   2017

Varsayılan olarak, groupby nesne, grup adıyla aynı etiket adına sahip.

Bir Grup Seçin

Kullanmak get_group() yöntemle tek bir grup seçebiliriz.

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')
print grouped.get_group(2014)

Onun output aşağıdaki gibidir -

Points  Rank     Team    Year
0     876     1   Riders    2014
2     863     2   Devils    2014
4     741     3   Kings     2014
9     701     4   Royals    2014

Toplamalar

Birleştirilmiş bir işlev, her grup için tek bir toplu değer döndürür. Bir keregroup by nesne oluşturulursa, gruplanmış veriler üzerinde birkaç toplama işlemi gerçekleştirilebilir.

Açık olanı, toplu veya eşdeğeri yoluyla kümelemedir agg yöntem -

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')
print grouped['Points'].agg(np.mean)

Onun output aşağıdaki gibidir -

Year
2014   795.25
2015   769.50
2016   725.00
2017   739.00
Name: Points, dtype: float64

Her grubun boyutunu görmenin başka bir yolu da size () işlevini uygulamaktır -

import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

Attribute Access in Python Pandas
grouped = df.groupby('Team')
print grouped.agg(np.size)

Onun output aşağıdaki gibidir -

Points   Rank   Year
Team
Devils        2      2      2
Kings         3      3      3
Riders        4      4      4
Royals        2      2      2
kings         1      1      1

Aynı Anda Birden Çok Toplama İşlevi Uygulama

Gruplandırılmış Seriler ile ayrıca bir list veya dict of functions DataFrame ile toplama yapmak ve çıktı olarak DataFrame oluşturmak için -

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Team')
print grouped['Points'].agg([np.sum, np.mean, np.std])

Onun output aşağıdaki gibidir -

Team      sum      mean          std
Devils   1536   768.000000   134.350288
Kings    2285   761.666667    24.006943
Riders   3049   762.250000    88.567771
Royals   1505   752.500000    72.831998
kings     812   812.000000          NaN

Dönüşümler

Bir grup veya bir sütundaki dönüştürme, gruplanmakta olanla aynı boyutta dizine alınmış bir nesne döndürür. Bu nedenle, dönüşüm bir grup öbeğiyle aynı boyutta bir sonuç döndürmelidir.

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print grouped.transform(score)

Onun output aşağıdaki gibidir -

Points        Rank        Year
0   12.843272  -15.000000  -11.618950
1   3.020286     5.000000   -3.872983
2   7.071068    -7.071068   -7.071068
3  -7.071068     7.071068    7.071068
4  -8.608621    11.547005  -10.910895
5        NaN          NaN         NaN
6  -2.360428    -5.773503    2.182179
7  10.969049    -5.773503    8.728716
8  -7.705963     5.000000    3.872983
9  -7.071068     7.071068   -7.071068
10  7.071068    -7.071068    7.071068
11 -8.157595     5.000000   11.618950

Filtrasyon

Filtreleme, verileri tanımlanmış bir kritere göre filtreler ve verilerin alt kümesini döndürür. filter() işlevi verileri filtrelemek için kullanılır.

import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team').filter(lambda x: len(x) >= 3)

Onun output aşağıdaki gibidir -

Points  Rank     Team   Year
0      876     1   Riders   2014
1      789     2   Riders   2015
4      741     3   Kings    2014
6      756     1   Kings    2016
7      788     1   Kings    2017
8      694     2   Riders   2016
11     690     2   Riders   2017

Yukarıdaki filtre koşulunda, IPL'ye üç veya daha fazla katılmış olan takımların iade edilmesini istiyoruz.

Pandalar, tam özellikli, yüksek performanslı bellek içi birleştirme işlemlerine deyimsel olarak SQL gibi ilişkisel veritabanlarına çok benzer.

Pandalar tek bir işlev sağlar, merge, DataFrame nesneleri arasındaki tüm standart veritabanı birleştirme işlemleri için giriş noktası olarak -

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True)

Burada aşağıdaki parametreleri kullandık -

left - Bir DataFrame nesnesi.
right - Başka bir DataFrame nesnesi.
on- Katılmak için sütunlar (isimler). Hem sol hem de sağ DataFrame nesnelerinde bulunmalıdır.
left_on- Anahtar olarak kullanmak için soldaki DataFrame'den sütunlar. DataFrame'in uzunluğuna eşit uzunlukta sütun adları veya diziler olabilir.
right_on- Anahtar olarak kullanmak için sağ DataFrame'den sütunlar. DataFrame'in uzunluğuna eşit uzunlukta sütun adları veya diziler olabilir.
left_index - eğer True,sol DataFrame'deki dizini (satır etiketleri) birleştirme anahtarları olarak kullanın. MultiIndex (hiyerarşik) içeren bir DataFrame olması durumunda, düzeylerin sayısı, sağ DataFrame'deki birleştirme anahtarlarının sayısıyla eşleşmelidir.
right_index - Aynı kullanım left_index Doğru DataFrame için.
how- "Sol", "sağ", "dış", "iç" ten biri. İç varsayılan. Her yöntem aşağıda açıklanmıştır.
sort- Sonuç DataFrame'i birleştirme anahtarlarına göre sözlüksel sırayla sıralayın. Varsayılan olarak True, False olarak ayarlamak çoğu durumda performansı önemli ölçüde artıracaktır.

Şimdi iki farklı DataFrame oluşturalım ve üzerinde birleştirme işlemlerini gerçekleştirelim.

# import the pandas library
import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame(
   {'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print left
print right

Onun output aşağıdaki gibidir -

Name  id   subject_id
0   Alex   1         sub1
1    Amy   2         sub2
2  Allen   3         sub4
3  Alice   4         sub6
4  Ayoung  5         sub5

    Name  id   subject_id
0  Billy   1         sub2
1  Brian   2         sub4
2  Bran    3         sub3
3  Bryce   4         sub6
4  Betty   5         sub5

Bir Anahtar Üzerinde İki Veri Çerçevesini Birleştirme

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
	'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on='id')

Onun output aşağıdaki gibidir -

Name_x   id  subject_id_x   Name_y   subject_id_y
0  Alex      1          sub1    Billy           sub2
1  Amy       2          sub2    Brian           sub4
2  Allen     3          sub4     Bran           sub3
3  Alice     4          sub6    Bryce           sub6
4  Ayoung    5          sub5    Betty           sub5

Birden Çok Anahtar Üzerinde İki Veri Çerçevesini Birleştirme

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
	'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on=['id','subject_id'])

Onun output aşağıdaki gibidir -

Name_x   id   subject_id   Name_y
0    Alice    4         sub6    Bryce
1   Ayoung    5         sub5    Betty

'Nasıl' Argümanını Kullanarak Birleştirme

howBirleştirme argümanı, ortaya çıkan tabloya hangi anahtarların dahil edileceğinin nasıl belirleneceğini belirtir. Sol veya sağ tablolarda bir tuş kombinasyonu görünmüyorsa, birleştirilmiş tablodaki değerler NA olacaktır.

İşte bir özeti how seçenekler ve bunların SQL eşdeğer isimleri -

Birleştirme Yöntemi	SQL Eşdeğeri	Açıklama
ayrıldı	SOL DIŞ KATILMA	Sol nesnedeki tuşları kullanın
sağ	RIGHT OUTER JOIN	Anahtarları doğru nesneden kullanın
dış	TAM DIŞ KATILIM	Anahtarların birleşimini kullan
iç	İÇ BİRLEŞİM	Anahtarların kesişimini kullanın

Sol yönden katılım

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='left')

Onun output aşağıdaki gibidir -

Name_x   id_x   subject_id   Name_y   id_y
0     Alex      1         sub1      NaN    NaN
1      Amy      2         sub2    Billy    1.0
2    Allen      3         sub4    Brian    2.0
3    Alice      4         sub6    Bryce    4.0
4   Ayoung      5         sub5    Betty    5.0

Sağ Katıl

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='right')

Onun output aşağıdaki gibidir -

Name_x  id_x   subject_id   Name_y   id_y
0      Amy   2.0         sub2    Billy      1
1    Allen   3.0         sub4    Brian      2
2    Alice   4.0         sub6    Bryce      4
3   Ayoung   5.0         sub5    Betty      5
4      NaN   NaN         sub3     Bran      3

Dış Birleştirme

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, how='outer', on='subject_id')

Onun output aşağıdaki gibidir -

Name_x  id_x   subject_id   Name_y   id_y
0     Alex   1.0         sub1      NaN    NaN
1      Amy   2.0         sub2    Billy    1.0
2    Allen   3.0         sub4    Brian    2.0
3    Alice   4.0         sub6    Bryce    4.0
4   Ayoung   5.0         sub5    Betty    5.0
5      NaN   NaN         sub3     Bran    3.0

İç birleşim

Birleştirme indekste yapılacaktır. Birleştirme işlemi çağrıldığı nesneyi onurlandırır. Yani,a.join(b) eşit değildir b.join(a).

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='inner')

Onun output aşağıdaki gibidir -

Name_x   id_x   subject_id   Name_y   id_y
0      Amy      2         sub2    Billy      1
1    Allen      3         sub4    Brian      2
2    Alice      4         sub6    Bryce      4
3   Ayoung      5         sub5    Betty      5

Pandalar, kolayca bir araya gelmek için çeşitli olanaklar sağlar Series, DataFrame, ve Panel nesneler.

pd.concat(objs,axis=0,join='outer',join_axes=None,
ignore_index=False)

objs - Bu, Series, DataFrame veya Panel nesnelerinin dizisi veya eşlemesidir.
axis - {0, 1, ...}, varsayılan 0. Bu, birlikte birleştirilecek eksendir.
join- {'iç', 'dış'}, varsayılan 'dış'. Diğer eksen (ler) de indeksler nasıl işlenir. Birleşim için dış ve kavşak için iç.
ignore_index- boole, varsayılan False. True ise, birleştirme eksenindeki dizin değerlerini kullanmayın. Ortaya çıkan eksen 0, ..., n - 1 olarak etiketlenecektir.
join_axes- Bu, Dizin nesnelerinin listesidir. İç / dış küme mantığını gerçekleştirmek yerine diğer (n-1) eksenler için kullanılacak özel dizinler.

Nesneleri Birleştirme

concatişlevi, bir eksen boyunca birleştirme işlemlerini gerçekleştirmenin tüm ağır işlerini yapar. Farklı nesneler yaratalım ve birleştirme yapalım.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two])

Onun output aşağıdaki gibidir -

Marks_scored     Name   subject_id
1             98     Alex         sub1
2             90      Amy         sub2
3             87    Allen         sub4
4             69    Alice         sub6
5             78   Ayoung         sub5
1             89    Billy         sub2
2             80    Brian         sub4
3             79     Bran         sub3
4             97    Bryce         sub6
5             88    Betty         sub5

Belirli anahtarları parçalanmış DataFrame'in her bir parçasıyla ilişkilendirmek istediğimizi varsayalım. Bunu kullanarak yapabilirizkeys argüman -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'])

Onun output aşağıdaki gibidir -

x  1  98    Alex    sub1
   2  90    Amy     sub2
   3  87    Allen   sub4
   4  69    Alice   sub6
   5  78    Ayoung  sub5
y  1  89    Billy   sub2
   2  80    Brian   sub4
   3  79    Bran    sub3
   4  97    Bryce   sub6
   5  88    Betty   sub5

Ortaya çıkan dizinin kopyalanması; her indeks tekrarlanır.

Ortaya çıkan nesnenin kendi indekslemesini izlemesi gerekiyorsa, ignore_index -e True.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'],ignore_index=True)

Onun output aşağıdaki gibidir -

Marks_scored     Name    subject_id
0             98     Alex          sub1
1             90      Amy          sub2
2             87    Allen          sub4
3             69    Alice          sub6
4             78   Ayoung          sub5
5             89    Billy          sub2
6             80    Brian          sub4
7             79     Bran          sub3
8             97    Bryce          sub6
9             88    Betty          sub5

İndeks tamamen değişir ve Anahtarlar da geçersiz kılınır.

İki nesnenin eklenmesi gerekiyorsa axis=1, ardından yeni sütunlar eklenecektir.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],axis=1)

Onun output aşağıdaki gibidir -

Marks_scored    Name  subject_id   Marks_scored    Name   subject_id
1           98      Alex      sub1         89         Billy         sub2
2           90       Amy      sub2         80         Brian         sub4
3           87     Allen      sub4         79          Bran         sub3
4           69     Alice      sub6         97         Bryce         sub6
5           78    Ayoung      sub5         88         Betty         sub5

Ek Kullanarak Birleştirme

Concat için kullanışlı bir kısayol, Series ve DataFrame üzerindeki örnek ekleme yöntemleridir. Bu yöntemler aslında concat'tan önce geldi. Birlikte bir araya geliyorlaraxis=0yani dizin -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print one.append(two)

Onun output aşağıdaki gibidir -

Marks_scored    Name  subject_id
1           98      Alex      sub1
2           90       Amy      sub2
3           87     Allen      sub4
4           69     Alice      sub6
5           78    Ayoung      sub5
1           89     Billy      sub2
2           80     Brian      sub4
3           79      Bran      sub3
4           97     Bryce      sub6
5           88     Betty      sub5

append işlevi birden fazla nesneyi de alabilir -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print one.append([two,one,two])

Onun output aşağıdaki gibidir -

Marks_scored   Name    subject_id
1           98     Alex          sub1
2           90      Amy          sub2
3           87    Allen          sub4
4           69    Alice          sub6
5           78   Ayoung          sub5
1           89    Billy          sub2
2           80    Brian          sub4
3           79     Bran          sub3
4           97    Bryce          sub6
5           88    Betty          sub5
1           98     Alex          sub1
2           90      Amy          sub2
3           87    Allen          sub4
4           69    Alice          sub6
5           78   Ayoung          sub5
1           89    Billy          sub2
2           80    Brian          sub4
3           79     Bran          sub3
4           97    Bryce          sub6
5           88    Betty          sub5

Zaman serisi

Pandalar, özellikle finans sektöründe Zaman serisi verileriyle çalışma süresi için sağlam bir araç sağlar. Zaman serisi verileriyle çalışırken sıklıkla aşağıdakilerle karşılaşırız:

Zaman dizisi oluşturma
Zaman serisini farklı frekanslara dönüştürün

Pandalar, yukarıdaki görevleri gerçekleştirmek için nispeten kompakt ve bağımsız bir araç seti sağlar.

Geçerli Saati Alın

datetime.now() size güncel tarih ve saati verir.

import pandas as pd

print pd.datetime.now()

Onun output aşağıdaki gibidir -

2017-05-11 06:10:13.393147

Bir TimeStamp oluşturun

Zaman damgalı veriler, değerleri zamandaki noktalarla ilişkilendiren en temel zaman serisi verileri türüdür. Pandaların nesneleri için, zaman içindeki noktaları kullanmak anlamına gelir. Bir örnek alalım -

import pandas as pd

print pd.Timestamp('2017-03-01')

Onun output aşağıdaki gibidir -

2017-03-01 00:00:00

Tamsayı veya float çağ zamanlarını dönüştürmek de mümkündür. Bunlar için varsayılan birim nanosaniyedir (çünkü bunlar Zaman Damgalarının nasıl saklandığıdır). Bununla birlikte, genellikle dönemler, belirlenebilen başka bir birimde saklanır. Başka bir örnek alalım

import pandas as pd

print pd.Timestamp(1587687255,unit='s')

Onun output aşağıdaki gibidir -

2020-04-24 00:14:15

Bir Zaman Aralığı Oluşturun

import pandas as pd

print pd.date_range("11:00", "13:30", freq="30min").time

Onun output aşağıdaki gibidir -

[datetime.time(11, 0) datetime.time(11, 30) datetime.time(12, 0)
datetime.time(12, 30) datetime.time(13, 0) datetime.time(13, 30)]

Zamanın Sıklığını Değiştirin

import pandas as pd

print pd.date_range("11:00", "13:30", freq="H").time

Onun output aşağıdaki gibidir -

[datetime.time(11, 0) datetime.time(12, 0) datetime.time(13, 0)]

Zaman Damgalarına Dönüştürme

Diziler, dönemler veya karışımlar gibi tarih benzeri nesnelerin Seri veya liste benzeri bir nesnesini dönüştürmek için, to_datetimeişlevi. Geçildiğinde, bu bir Seri (aynı indeksle) döndürürken,list-like bir DatetimeIndex. Aşağıdaki örneğe bir göz atın -

import pandas as pd

print pd.to_datetime(pd.Series(['Jul 31, 2009','2010-01-10', None]))

Onun output aşağıdaki gibidir -

0  2009-07-31
1  2010-01-10
2         NaT
dtype: datetime64[ns]

NaT anlamına geliyor Not a Time (NaN'ye eşdeğer)

Başka bir örnek alalım.

import pandas as pd

print pd.to_datetime(['2005/11/23', '2010.12.31', None])

Onun output aşağıdaki gibidir -

DatetimeIndex(['2005-11-23', '2010-12-31', 'NaT'], dtype='datetime64[ns]', freq=None)

Zaman serisini genişleten Tarih işlevleri, finansal veri analizinde önemli bir rol oynar. Tarih verileriyle çalışırken sıklıkla aşağıdakilerle karşılaşırız -

Tarih dizisi oluşturma
Tarih serisini farklı frekanslara dönüştürün

Tarih Aralığı Oluşturun

Kullanmak date.range()fonksiyon periyotlarını ve sıklığını belirterek tarih serilerini oluşturabiliriz. Varsayılan olarak, aralığın sıklığı Gün'dür.

import pandas as pd

print pd.date_range('1/1/2011', periods=5)

Onun output aşağıdaki gibidir -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Tarih Sıklığını Değiştirin

import pandas as pd

print pd.date_range('1/1/2011', periods=5,freq='M')

Onun output aşağıdaki gibidir -

DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31', '2011-04-30', '2011-05-31'],
   dtype='datetime64[ns]', freq='M')

bdate_range

bdate_range (), iş tarihi aralıkları anlamına gelir. Date_range () 'den farklı olarak, Cumartesi ve Pazar günleri hariçtir.

import pandas as pd

print pd.date_range('1/1/2011', periods=5)

Onun output aşağıdaki gibidir -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

3 Mart'tan sonra tarihin 4 ve 5'i hariç 6 Mart'a atladığını gözlemleyin. Günler için takviminize bakın.

Kullanışlı fonksiyonlar gibi date_range ve bdate_rangeçeşitli sıklık takma adları kullanır. Tarih_aralığı için varsayılan sıklık bir takvim günü iken bdate_range için varsayılan bir iş günüdür.

import pandas as pd
start = pd.datetime(2011, 1, 1)
end = pd.datetime(2011, 1, 5)

print pd.date_range(start, end)

Onun output aşağıdaki gibidir -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Ofset Takma Adları

Kullanışlı ortak zaman serisi frekanslarına bir dizi dizi takma adı verilmiştir. Bu takma adlara ofset takma adları olarak değineceğiz.

Takma ad	Açıklama	Takma ad	Açıklama
B	iş günü sıklığı	BQS	iş çeyreği başlangıç sıklığı
D	takvim günü sıklığı	Bir	yıllık (Yıl) bitiş sıklığı
W	haftalık sıklık	BA	iş yılı sonu sıklığı
M	ay sonu sıklığı	BAS	iş yılı başlangıç sıklığı
SM	yarı ay sonu sıklığı	BH	iş saati sıklığı
BM	iş ayı sonu sıklığı	H	saatlik frekans
HANIM	ay başlangıç sıklığı	T, min	dakika frekansı
SMS	SMS yarı aylık başlangıç sıklığı	S	ikinci frekans
BMS	iş ayı başlangıç sıklığı	L, ms	milisaniye
Q	çeyrek sonu sıklığı	U, biz	mikrosaniye
BQ	iş çeyrek sonu sıklığı	N	nanosaniye
QS	çeyrek başlangıç frekansı

Zaman çizelgeleri, örneğin günler, saatler, dakikalar, saniyeler gibi fark birimleriyle ifade edilen zaman farklılıklarıdır. Hem olumlu hem de olumsuz olabilirler.

Aşağıda gösterildiği gibi çeşitli argümanlar kullanarak Timedelta nesneleri oluşturabiliriz -

Dize

Bir dizge değişmezi geçirerek, bir timedelta nesnesi oluşturabiliriz.

import pandas as pd

print pd.Timedelta('2 days 2 hours 15 minutes 30 seconds')

Onun output aşağıdaki gibidir -

2 days 02:15:30

Tamsayı

Birimle bir tamsayı değeri ileterek, bir argüman bir Timedelta nesnesi oluşturur.

import pandas as pd

print pd.Timedelta(6,unit='h')

Onun output aşağıdaki gibidir -

0 days 06:00:00

Veri Ofsetleri

Haftalar, günler, saatler, dakikalar, saniyeler, milisaniyeler, mikrosaniyeler, nanosaniyeler gibi veri ofsetleri de inşaatta kullanılabilir.

import pandas as pd

print pd.Timedelta(days=2)

Onun output aşağıdaki gibidir -

2 days 00:00:00

to_timedelta ()

En üst seviyeyi kullanma pd.to_timedelta, tanınan bir timedelta biçiminden / değerinden bir skaler, dizi, liste veya diziyi Timedelta türüne dönüştürebilirsiniz. Giriş bir Seri ise Seri oluşturur, giriş skaler benzeri ise bir skaler, aksi takdirde bir çıktı verirTimedeltaIndex.

import pandas as pd

print pd.Timedelta(days=2)

Onun output aşağıdaki gibidir -

2 days 00:00:00

Operasyonlar

Series / DataFrames üzerinde çalışabilir ve inşa edebilirsiniz timedelta64[ns] Üzerinde çıkarma işlemleri yoluyla seriler datetime64[ns] Seri veya Zaman Damgaları.

Şimdi Timedelta ve datetime nesneleriyle bir DataFrame oluşturalım ve üzerinde bazı aritmetik işlemler gerçekleştirelim -

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))

print df

Onun output aşağıdaki gibidir -

A      B
0  2012-01-01 0 days
1  2012-01-02 1 days
2  2012-01-03 2 days

Toplama İşlemleri

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']

print df

Onun output aşağıdaki gibidir -

A      B          C
0 2012-01-01 0 days 2012-01-01
1 2012-01-02 1 days 2012-01-03
2 2012-01-03 2 days 2012-01-05

Çıkarma İşlemi

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
df['D']=df['C']+df['B']

print df

Onun output aşağıdaki gibidir -

A      B          C          D
0 2012-01-01 0 days 2012-01-01 2012-01-01
1 2012-01-02 1 days 2012-01-03 2012-01-04
2 2012-01-03 2 days 2012-01-05 2012-01-07

Genellikle gerçek zamanlı olarak veriler, tekrarlayan metin sütunlarını içerir. Cinsiyet, ülke ve kodlar gibi özellikler her zaman tekrarlanır. Bunlar kategorik veriler için örneklerdir.

Kategorik değişkenler yalnızca sınırlı ve genellikle sabit sayıda olası değer alabilir. Sabit uzunluğun yanı sıra, kategorik veriler bir sıraya sahip olabilir ancak sayısal işlem gerçekleştiremez. Kategorik, Pandalar veri türüdür.

Kategorik veri türü aşağıdaki durumlarda kullanışlıdır -

Yalnızca birkaç farklı değerden oluşan bir dize değişkeni. Böyle bir dizgi değişkenini kategorik bir değişkene dönüştürmek hafızada bir miktar tasarruf sağlayacaktır.
Bir değişkenin sözlü sıralaması mantıksal sıra ile aynı değildir ("bir", "iki", "üç"). Kategoriye dönüştürerek ve kategoriler üzerinde bir sıralama belirleyerek, sıralama ve min / maks, sözcük düzeni yerine mantıksal sıralamayı kullanacaktır.
Diğer python kitaplıklarına, bu sütunun kategorik bir değişken olarak ele alınması gerektiğine dair bir sinyal olarak (örneğin, uygun istatistiksel yöntemler veya çizim türlerini kullanmak için).

Nesne Oluşturma

Kategorik nesne birden çok yolla oluşturulabilir. Farklı yollar aşağıda açıklanmıştır -

kategori

Pandalar nesne oluştururken dtype'ı "kategori" olarak belirterek.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print s

Onun output aşağıdaki gibidir -

0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

Seri nesnesine aktarılan öğelerin sayısı dörttür, ancak kategoriler yalnızca üçtür. Aynı şeyi çıktı kategorilerinde de gözlemleyin.

pd. Kategorik

Standart pandalar Categorical yapıcısını kullanarak bir kategori nesnesi oluşturabiliriz.

pandas.Categorical(values, categories, ordered)

Bir örnek alalım -

import pandas as pd

cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print cat

Onun output aşağıdaki gibidir -

[a, b, c, a, b, c]
Categories (3, object): [a, b, c]

Başka bir örnek verelim -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
print cat

Onun output aşağıdaki gibidir -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c, b, a]

Burada ikinci argüman kategorileri belirtir. Bu nedenle, kategorilerde bulunmayan herhangi bir değer,NaN.

Şimdi, aşağıdaki örneğe bir göz atın -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
print cat

Onun output aşağıdaki gibidir -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c < b < a]

Mantıksal olarak, sipariş şu anlama gelir: a daha büyüktür b ve b daha büyüktür c.

Açıklama

Kullanmak .describe() kategorik verilerdeki komuta benzer bir çıktı elde ederiz. Series veya DataFrame of type dize.

import pandas as pd
import numpy as np

cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
df = pd.DataFrame({"cat":cat, "s":["a", "c", "c", np.nan]})

print df.describe()
print df["cat"].describe()

Onun output aşağıdaki gibidir -

cat s
count    3 3
unique   2 2
top      c c
freq     2 2
count     3
unique    2
top       c
freq      2
Name: cat, dtype: object

Kategorinin Özelliklerini Alın

obj.cat.categories komutu almak için kullanılır categories of the object.

import pandas as pd
import numpy as np

s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print s.categories

Onun output aşağıdaki gibidir -

Index([u'b', u'a', u'c'], dtype='object')

obj.ordered komutu nesnenin sırasını almak için kullanılır.

import pandas as pd
import numpy as np

cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print cat.ordered

Onun output aşağıdaki gibidir -

False

İşlev döndürüldü false çünkü herhangi bir sipariş belirtmedik.

Kategorileri Yeniden Adlandırma

Kategorilerin yeniden adlandırılması, yeni değerler atanarak yapılır. series.cat.categoriesseries.cat.categories özelliği.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
s.cat.categories = ["Group %s" % g for g in s.cat.categories]
print s.cat.categories

Onun output aşağıdaki gibidir -

Index([u'Group a', u'Group b', u'Group c'], dtype='object')

İlk kategoriler [a,b,c] tarafından güncellenir s.cat.categories nesnenin özelliği.

Yeni Kategoriler Ekleme

Categorical.add.categories () yöntemi kullanılarak yeni kategoriler eklenebilir.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
s = s.cat.add_categories([4])
print s.cat.categories

Onun output aşağıdaki gibidir -

Index([u'a', u'b', u'c', 4], dtype='object')

Kategorileri Kaldırma

Kullanmak Categorical.remove_categories() yöntem, istenmeyen kategoriler kaldırılabilir.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print ("Original object:")
print s

print ("After removal:")
print s.cat.remove_categories("a")

Onun output aşağıdaki gibidir -

Original object:
0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

After removal:
0  NaN
1  b
2  c
3  NaN
dtype: category
Categories (2, object): [b, c]

Kategorik Verilerin Karşılaştırılması

Kategorik verileri diğer nesnelerle karşılaştırmak üç durumda mümkündür -

eşitliği (== ve! =) kategorik verilerle aynı uzunluktaki liste benzeri bir nesneyle (liste, Seri, dizi, ...) karşılaştırmak.
tüm karşılaştırmalar (==,! =,>,> =, <ve <=) başka bir kategorik Seriyle, sipariş edildiğinde == Doğru ve kategoriler aynıdır.
kategorik bir verinin bir skaler ile tüm karşılaştırmaları.

Aşağıdaki örneğe bir göz atın -

import pandas as pd

cat = pd.Series([1,2,3]).astype("category", categories=[1,2,3], ordered=True)
cat1 = pd.Series([2,2,2]).astype("category", categories=[1,2,3], ordered=True)

print cat>cat1

Onun output aşağıdaki gibidir -

0  False
1  False
2  True
dtype: bool

Temel Çizim: arsa

Series ve DataFrame'deki bu işlevsellik, yalnızca matplotlib libraries plot() yöntem.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10,4),index=pd.date_range('1/1/2000',
   periods=10), columns=list('ABCD'))

df.plot()

Onun output aşağıdaki gibidir -

Dizin tarihlerden oluşuyorsa, gct().autofmt_xdate() x eksenini yukarıdaki şekilde gösterildiği gibi biçimlendirmek için.

Bir sütunu diğerine karşı çizebiliriz x ve y anahtar kelimeler.

Çizim yöntemleri, varsayılan çizgi grafiği dışında bir avuç çizim stiline izin verir. Bu yöntemler tür anahtar kelime bağımsız değişkeni olarak sağlanabilirplot(). Bunlar arasında -

bar arazileri için bar veya barh
histogram için geçmiş
kutu çizimi için kutu
Alan grafikleri için "alan"
dağılım grafikleri için "dağılım"

Bar Grafiği

Şimdi Bar Plot'un ne olduğunu bir tane oluşturarak görelim. Bir çubuk grafiği şu şekilde oluşturulabilir -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar()

Onun output aşağıdaki gibidir -

Yığılmış çubuk grafiği oluşturmak için, pass stacked=True -

import pandas as pd
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar(stacked=True)

Onun output aşağıdaki gibidir -

Yatay çubuk grafikleri elde etmek için, barh yöntem -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')

df.plot.barh(stacked=True)

Onun output aşağıdaki gibidir -

Histogramlar

Histogramlar, plot.hist()yöntem. Kutu sayısını belirleyebiliriz.

import pandas as pd
import numpy as np

df = pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])

df.plot.hist(bins=20)

Onun output aşağıdaki gibidir -

Her sütun için farklı histogramlar çizmek için aşağıdaki kodu kullanın -

import pandas as pd
import numpy as np

df=pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])

df.diff.hist(bins=20)

Onun output aşağıdaki gibidir -

Kutu Grafikleri

Boxplot arayarak çizilebilir Series.box.plot() ve DataFrame.box.plot()veya DataFrame.boxplot() her sütundaki değerlerin dağılımını görselleştirmek için.

Örneğin, burada [0,1) üzerindeki tekdüze bir rastgele değişkenin 10 gözleminin beş denemesini temsil eden bir kutu grafiği var.

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])
df.plot.box()

Onun output aşağıdaki gibidir -

Alan Grafiği

Alan grafiği kullanılarak oluşturulabilir Series.plot.area() ya da DataFrame.plot.area() yöntemler.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])
df.plot.area()

Onun output aşağıdaki gibidir -

Dağılım grafiği

Dağılım grafiği kullanılarak oluşturulabilir DataFrame.plot.scatter() yöntemler.

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(50, 4), columns=['a', 'b', 'c', 'd'])
df.plot.scatter(x='a', y='b')

Onun output aşağıdaki gibidir -

Yuvarlak diyagram

Pasta grafik, DataFrame.plot.pie() yöntem.

import pandas as pd
import numpy as np

df = pd.DataFrame(3 * np.random.rand(4), index=['a', 'b', 'c', 'd'], columns=['x'])
df.plot.pie(subplots=True)

Onun output aşağıdaki gibidir -

Pandas I/O API gibi erişilen bir üst düzey okuyucu işlevleri kümesidir. pd.read_csv() genellikle bir Pandas nesnesi döndürür.

Metin dosyalarını (veya düz dosyaları) okumak için iki iş gücü işlevi read_csv() ve read_table(). Her ikisi de aynı ayrıştırma kodunu kullanarak tablo verilerini akıllıca birDataFrame nesne -

pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
names=None, index_col=None, usecols=None

pandas.read_csv(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None

İşte nasıl csv dosya verileri şöyle görünür -

S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900

Bu verileri farklı kaydedin temp.csv ve üzerinde işlem yapmak.

S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900

Bu verileri farklı kaydedin temp.csv ve üzerinde işlem yapmak.

read.csv

read.csv csv dosyalarındaki verileri okur ve bir DataFrame nesnesi oluşturur.

import pandas as pd

df=pd.read_csv("temp.csv")
print df

Onun output aşağıdaki gibidir -

S.No     Name   Age       City   Salary
0     1      Tom    28    Toronto    20000
1     2      Lee    32   HongKong     3000
2     3   Steven    43   Bay Area     8300
3     4      Ram    38  Hyderabad     3900

özel dizin

Bu, csv dosyasında dizini özelleştirmek için bir sütun belirtir. index_col.

import pandas as pd

df=pd.read_csv("temp.csv",index_col=['S.No'])
print df

Onun output aşağıdaki gibidir -

S.No   Name   Age       City   Salary
1       Tom    28    Toronto    20000
2       Lee    32   HongKong     3000
3    Steven    43   Bay Area     8300
4       Ram    38  Hyderabad     3900

Dönüştürücüler

dtype sütun sayısı bir dikt olarak aktarılabilir.

import pandas as pd

df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print df.dtypes

Onun output aşağıdaki gibidir -

S.No       int64
Name      object
Age        int64
City      object
Salary   float64
dtype: object

Varsayılan olarak, dtype Maaş sütununun int, ancak sonuç bunu gösteriyor float çünkü türü açıkça belirledik.

Böylece, veriler float gibi görünür -

S.No   Name   Age      City    Salary
0   1     Tom   28    Toronto   20000.0
1   2     Lee   32   HongKong    3000.0
2   3  Steven   43   Bay Area    8300.0
3   4     Ram   38  Hyderabad    3900.0

header_names

Names argümanını kullanarak başlığın adlarını belirtin.

import pandas as pd
 
df=pd.read_csv("temp.csv", names=['a', 'b', 'c','d','e'])
print df

Onun output aşağıdaki gibidir -

a        b    c           d        e
0   S.No     Name   Age       City   Salary
1      1      Tom   28     Toronto    20000
2      2      Lee   32    HongKong     3000
3      3   Steven   43    Bay Area     8300
4      4      Ram   38   Hyderabad     3900

Dikkat edin, başlık adlarına özel adlar eklenir, ancak dosyadaki başlık kaldırılmamıştır. Şimdi, bunu kaldırmak için başlık argümanını kullanıyoruz.

Başlık birinciden farklı bir satırdaysa, satır numarasını başlığa iletin. Bu, önceki satırları atlayacaktır.

import pandas as pd 

df=pd.read_csv("temp.csv",names=['a','b','c','d','e'],header=0)
print df

Onun output aşağıdaki gibidir -

a        b    c           d        e
0  S.No     Name   Age       City   Salary
1     1      Tom   28     Toronto    20000
2     2      Lee   32    HongKong     3000
3     3   Steven   43    Bay Area     8300
4     4      Ram   38   Hyderabad     3900

satır atlamak

skiprows, belirtilen satır sayısını atlar.

import pandas as pd

df=pd.read_csv("temp.csv", skiprows=2)
print df

Onun output aşağıdaki gibidir -

2      Lee   32    HongKong   3000
0   3   Steven   43    Bay Area   8300
1   4      Ram   38   Hyderabad   3900

Seyrek nesneler, belirli bir değerle eşleşen herhangi bir veri (NaN / eksik değer, ancak herhangi bir değer seçilebilir) çıkarıldığında "sıkıştırılır". Özel bir SparseIndex nesnesi, verilerin "dağıtıldığı" yerleri izler. Bu, bir örnekte çok daha mantıklı olacaktır. Tüm standart Pandalar veri yapıları,to_sparse yöntem -

import pandas as pd
import numpy as np

ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts

Onun output aşağıdaki gibidir -

0   -0.810497
1   -1.419954
2         NaN
3         NaN
4         NaN
5         NaN
6         NaN
7         NaN
8    0.439240
9   -1.095910
dtype: float64
BlockIndex
Block locations: array([0, 8], dtype=int32)
Block lengths: array([2, 2], dtype=int32)

Seyrek nesneler, bellek verimliliği nedenleriyle mevcuttur.

Şimdi büyük bir NA DataFrame'iniz olduğunu varsayalım ve aşağıdaki kodu çalıştıralım -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10000, 4))
df.ix[:9998] = np.nan
sdf = df.to_sparse()

print sdf.density

Onun output aşağıdaki gibidir -

0.0001

Seyrek herhangi bir nesne, çağrı yapılarak standart yoğun forma geri dönüştürülebilir to_dense -

import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts.to_dense()

Onun output aşağıdaki gibidir -

0   -0.810497
1   -1.419954
2         NaN
3         NaN
4         NaN
5         NaN
6         NaN
7         NaN
8    0.439240
9   -1.095910
dtype: float64

Seyrek Tipler

Seyrek veriler, yoğun temsiliyle aynı dtipe sahip olmalıdır. Şu anda,float64, int64 ve booldtypesDesteklenmektedir. Orijinale bağlı olarakdtype, fill_value default değişiklikler -

float64 - np.nan
int64 - 0
bool - Yanlış

Aynısını anlamak için aşağıdaki kodu çalıştıralım -

import pandas as pd
import numpy as np

s = pd.Series([1, np.nan, np.nan])
print s

s.to_sparse()
print s

Onun output aşağıdaki gibidir -

0   1.0
1   NaN
2   NaN
dtype: float64

0   1.0
1   NaN
2   NaN
dtype: float64

Uyarılar uyarı anlamına gelir ve aldatma, görünmeyen bir sorun anlamına gelir.

Pandalarla If / Truth İfadesini Kullanma

Pandalar, bir şeyi bir şeye dönüştürmeye çalıştığınızda, uyuşmuş bir hata yapma kuralını izler. bool. Bu birif veya when Boolean işlemlerini kullanarak ve, orveya not. Sonucun ne olması gerektiği belli değil. Sıfır uzunlukta olmadığı için Doğru mu olmalı? Yanlış çünkü Yanlış değerler var mı? Belirsizdir, dolayısıyla Pandalar birValueError -

import pandas as pd

if pd.Series([False, True, False]):
   print 'I am True'

Onun output aşağıdaki gibidir -

ValueError: The truth value of a Series is ambiguous. 
Use a.empty, a.bool() a.item(),a.any() or a.all().

İçinde ifdurum, onunla ne yapılacağı belli değil. Hata, birNone veya any of those.

import pandas as pd

if pd.Series([False, True, False]).any():
   print("I am any")

Onun output aşağıdaki gibidir -

I am any

Bir Boole bağlamında tek öğeli panda nesnelerini değerlendirmek için yöntemi kullanın .bool() -

import pandas as pd

print pd.Series([True]).bool()

Onun output aşağıdaki gibidir -

True

Bitsel Boole

== ve gibi Bitsel Boole operatörleri != Neredeyse her zaman gerekli olan bir Boolean serisi döndürecektir.

import pandas as pd

s = pd.Series(range(5))
print s==4

Onun output aşağıdaki gibidir -

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

isin Operasyonu

Bu, Serideki her öğenin tam olarak geçirilen değerler dizisinde yer alıp almadığını gösteren bir Boole dizisi döndürür.

import pandas as pd

s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print s

Onun output aşağıdaki gibidir -

0 True
1 False
2 True
dtype: bool

Yeniden dizin oluşturma ve ix Gotcha

Birçok kullanıcı kendilerini ix indexing capabilities bir Pandas nesnesinden veri seçmenin özlü bir yolu olarak -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.ix[['b', 'c', 'e']]

Onun output aşağıdaki gibidir -

one        two      three       four
a   -1.582025   1.335773   0.961417  -1.272084
b    1.461512   0.111372  -0.072225   0.553058
c   -1.240671   0.762185   1.511936  -0.630920
d   -2.380648  -0.029981   0.196489   0.531714
e    1.846746   0.148149   0.275398  -0.244559
f   -1.842662  -0.933195   2.303949   0.677641

          one        two      three       four
b    1.461512   0.111372  -0.072225   0.553058
c   -1.240671   0.762185   1.511936  -0.630920
e    1.846746   0.148149   0.275398  -0.244559

Bu, elbette, bu durumda tamamen reindex yöntem -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.reindex(['b', 'c', 'e'])

Onun output aşağıdaki gibidir -

one        two      three       four
a    1.639081   1.369838   0.261287  -1.662003
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
d   -1.078791  -0.612607  -0.897289  -1.146893
e    0.465215   1.552873  -1.841959   0.329404
f    0.966022  -0.190077   1.324247   0.678064

          one        two      three       four
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
e    0.465215   1.552873  -1.841959   0.329404

Bazıları şu sonuca varabilir: ix ve reindexbuna göre% 100 eşdeğerdir. Bu, tamsayı indeksleme durumu dışında geçerlidir. Örneğin, yukarıdaki işlem alternatif olarak şu şekilde ifade edilebilir -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.ix[[1, 2, 4]]
print df.reindex([1, 2, 4])

Onun output aşağıdaki gibidir -

one        two      three       four
a   -1.015695  -0.553847   1.106235  -0.784460
b   -0.527398  -0.518198  -0.710546  -0.512036
c   -0.842803  -1.050374   0.787146   0.205147
d   -1.238016  -0.749554  -0.547470  -0.029045
e   -0.056788   1.063999  -0.767220   0.212476
f    1.139714   0.036159   0.201912   0.710119

          one        two      three       four
b   -0.527398  -0.518198  -0.710546  -0.512036
c   -0.842803  -1.050374   0.787146   0.205147
e   -0.056788   1.063999  -0.767220   0.212476

    one  two  three  four
1   NaN  NaN    NaN   NaN
2   NaN  NaN    NaN   NaN
4   NaN  NaN    NaN   NaN

Bunu hatırlamak önemlidir reindex is strict label indexing only. Bu, bir indeksin, örneğin hem tamsayılar hem de dizeler içerdiği patolojik durumlarda bazı potansiyel olarak şaşırtıcı sonuçlara yol açabilir.

Pek çok potansiyel Pandas kullanıcısı SQL konusunda biraz bilgi sahibi olduğundan, bu sayfanın pandalar kullanılarak çeşitli SQL işlemlerinin nasıl gerçekleştirilebileceğine dair bazı örnekler sağlaması amaçlanmıştır.

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips.head()

Onun output aşağıdaki gibidir -

total_bill   tip      sex  smoker  day     time  size
0        16.99  1.01   Female      No  Sun  Dinner      2
1        10.34  1.66     Male      No  Sun  Dinner      3
2        21.01  3.50     Male      No  Sun  Dinner      3
3        23.68  3.31     Male      No  Sun  Dinner      2
4        24.59  3.61   Female      No  Sun  Dinner      4

SEÇ

SQL'de seçim, seçtiğiniz virgülle ayrılmış sütun listesi (veya tüm sütunları seçmek için *) kullanılarak yapılır -

SELECT total_bill, tip, smoker, time
FROM tips
LIMIT 5;

Pandalar ile sütun seçimi, DataFrame'inize bir sütun adları listesi iletilerek yapılır -

tips[['total_bill', 'tip', 'smoker', 'time']].head(5)

Tam programı kontrol edelim -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
 
tips=pd.read_csv(url)
print tips[['total_bill', 'tip', 'smoker', 'time']].head(5)

Onun output aşağıdaki gibidir -

total_bill   tip  smoker     time
0       16.99  1.01      No   Dinner
1       10.34  1.66      No   Dinner
2       21.01  3.50      No   Dinner
3       23.68  3.31      No   Dinner
4       24.59  3.61      No   Dinner

DataFrame'i sütun adları listesi olmadan çağırmak tüm sütunları görüntüler (SQL'in * ile benzer).

NEREDE

SQL'de filtreleme bir WHERE cümlesiyle yapılır.

SELECT * FROM tips WHERE time = 'Dinner' LIMIT 5;

DataFrame'ler birçok şekilde filtrelenebilir; en sezgisel olanı Boolean indekslemeyi kullanmaktır.

tips[tips['time'] == 'Dinner'].head(5)

Tam programı kontrol edelim -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips[tips['time'] == 'Dinner'].head(5)

Onun output aşağıdaki gibidir -

total_bill   tip      sex  smoker  day    time  size
0       16.99  1.01   Female     No   Sun  Dinner    2
1       10.34  1.66     Male     No   Sun  Dinner    3
2       21.01  3.50     Male     No   Sun  Dinner    3
3       23.68  3.31     Male     No   Sun  Dinner    2
4       24.59  3.61   Female     No   Sun  Dinner    4

Yukarıdaki ifade, DataFrame'e bir Dizi Doğru / Yanlış nesneler geçirerek tüm satırları True ile döndürür.

GroupBy

Bu işlem, bir veri kümesi boyunca her bir gruptaki kayıtların sayısını getirir. Örneğin, bize cinsiyetin bıraktığı ipucu sayısını getiren bir sorgu -

SELECT sex, count(*)
FROM tips
GROUP BY sex;

Pandaların eşdeğeri şöyle olacaktır:

tips.groupby('sex').size()

Tam programı kontrol edelim -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips.groupby('sex').size()

Onun output aşağıdaki gibidir -

sex
Female   87
Male    157
dtype: int64

İlk N satır

SQL, top n rows kullanma LIMIT -

SELECT * FROM tips
LIMIT 5 ;

Pandaların eşdeğeri şöyle olacaktır:

tips.head(5)

Tam örneği kontrol edelim -

import pandas as pd

url = 'https://raw.github.com/pandas-dev/pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
tips = tips[['smoker', 'day', 'time']].head(5)
print tips

Onun output aşağıdaki gibidir -

smoker   day     time
0      No   Sun   Dinner
1      No   Sun   Dinner
2      No   Sun   Dinner
3      No   Sun   Dinner
4      No   Sun   Dinner

Bunlar, Pandas Kütüphanesinin önceki bölümlerinde öğrendiğimiz, karşılaştırdığımız birkaç temel işlemdir.