Python Pandas - szybki przewodnik

Pandas to biblioteka języka Python o otwartym kodzie źródłowym zapewniająca wydajne narzędzie do manipulacji i analizy danych przy użyciu potężnych struktur danych. Nazwa Pandy pochodzi od słowa Panel Data - an Econometrics from Multidimensional danych.

W 2008 roku deweloper Wes McKinney zaczął tworzyć pandy, gdy potrzebował wydajnego, elastycznego narzędzia do analizy danych.

Przed Pandas, Python był głównie używany do zmiany danych i przygotowania. Miał bardzo niewielki wkład w analizę danych. Pandy rozwiązały ten problem. Korzystając z Pandas, możemy wykonać pięć typowych kroków w przetwarzaniu i analizie danych, niezależnie od ich pochodzenia - ładowanie, przygotowywanie, manipulowanie, modelowanie i analizowanie.

Python with Pandas jest używany w wielu dziedzinach, w tym w dziedzinach akademickich i komercyjnych, w tym w finansach, ekonomii, statystyce, analityce itp.

Kluczowe cechy Pand

Szybki i wydajny obiekt DataFrame z domyślnym i dostosowanym indeksowaniem.
Narzędzia do ładowania danych do obiektów danych w pamięci z różnych formatów plików.
Dopasowanie danych i zintegrowana obsługa brakujących danych.
Przekształcanie i obracanie zestawów dat.
Krojenie na podstawie etykiet, indeksowanie i podzbiór dużych zbiorów danych.
Kolumny ze struktury danych można usuwać lub wstawiać.
Grupuj według danych w celu agregacji i przekształceń.
Wysokowydajne scalanie i łączenie danych.
Funkcjonalność szeregów czasowych.

Standardowa dystrybucja Pythona nie jest dostarczana w pakiecie z modułem Pandas. Lekką alternatywą jest instalacja NumPy za pomocą popularnego instalatora pakietów Pythona,pip.

pip install pandas

Jeśli zainstalujesz pakiet Anaconda Python, Pandy zostaną zainstalowane domyślnie z następującymi -

Windows

Anaconda (od https://www.continuum.io) to darmowa dystrybucja Pythona dla stosu SciPy. Jest również dostępny dla systemów Linux i Mac.
Canopy (https://www.enthought.com/products/canopy/) jest dostępny zarówno jako bezpłatna, jak i komercyjna dystrybucja z pełnym stosem SciPy dla systemów Windows, Linux i Mac.
Python(x, y) to darmowa dystrybucja Pythona ze stosem SciPy i Spyder IDE dla systemu operacyjnego Windows. (Do pobrania zhttp://python-xy.github.io/)

Linux

Menedżery pakietów odpowiednich dystrybucji Linuksa są używane do instalowania jednego lub więcej pakietów na stosie SciPy.

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

Pandas radzi sobie z następującymi trzema strukturami danych -

Series
DataFrame
Panel

Te struktury danych są zbudowane na podstawie tablicy Numpy, co oznacza, że są szybkie.

Wymiar i opis

Najlepszym sposobem myślenia o tych strukturach danych jest to, że wyżej wymiarowa struktura danych jest zbiornikiem jej niższej wymiarowej struktury danych. Na przykład DataFrame jest kontenerem Series, Panel jest kontenerem DataFrame.

Struktura danych	Wymiary	Opis
Seria	1	Jednorodna tablica znakowana 1D, z możliwością zmiany rozmiaru.
Ramki danych	2	Ogólna struktura tabelaryczna oznaczona etykietami 2D, z możliwością zmiany rozmiaru, z potencjalnie niejednorodnymi typami kolumn.
Płyta	3	Ogólna tablica znakowana 3D, zmienna wielkość.

Budowanie i obsługa dwu- lub więcej wymiarowych tablic jest żmudnym zadaniem, podczas pisania funkcji na użytkowniku spoczywa ciężar rozważenia orientacji zestawu danych. Jednak użycie struktur danych Pandas ogranicza wysiłek umysłowy użytkownika.

Na przykład w przypadku danych tabelarycznych (DataFrame) bardziej semantycznie pomocne jest myślenie o index (rzędy) i columns zamiast osi 0 i osi 1.

Zmienność

Wszystkie struktury danych Pandas są wartościami zmiennymi (można je zmienić), a poza seriami wszystkie mają zmienną wielkość. Seria ma niezmienną wielkość.

Note- DataFrame jest szeroko stosowana i jest jedną z najważniejszych struktur danych. Panel jest używany znacznie mniej.

Seria

Szereg to jednowymiarowa struktura przypominająca tablicę z jednorodnymi danymi. Na przykład poniższa seria to zbiór liczb całkowitych 10, 23, 56,…

10	23	56	17	52	61	73	90	26	72

Kluczowe punkty

Jednorodne dane
Niezmienny rozmiar
Wartości zmiennych danych

Ramka danych

DataFrame to dwuwymiarowa tablica z niejednorodnymi danymi. Na przykład,

Nazwa	Wiek	Płeć	Ocena
Steve	32	Męski	3.45
Lia	28	Płeć żeńska	4.6
Vin	45	Męski	3.9
Katie	38	Płeć żeńska	2,78

Tabela przedstawia dane zespołu sprzedażowego organizacji wraz z ogólną oceną wydajności. Dane są przedstawiane w wierszach i kolumnach. Każda kolumna reprezentuje atrybut, a każdy wiersz reprezentuje osobę.

Typ danych kolumn

Typy danych w czterech kolumnach są następujące -

Kolumna	Rodzaj
Nazwa	Strunowy
Wiek	Liczba całkowita
Płeć	Strunowy
Ocena	Pływak

Kluczowe punkty

Dane heterogeniczne
Rozmiar zmienny
Zmienne dane

Płyta

Panel to trójwymiarowa struktura danych z niejednorodnymi danymi. Trudno jest przedstawić panel w graficznej reprezentacji. Ale panel można zilustrować jako kontener DataFrame.

Kluczowe punkty

Dane heterogeniczne
Rozmiar zmienny
Zmienne dane

Seria to jednowymiarowa tablica z etykietami, która może przechowywać dane dowolnego typu (liczby całkowite, ciągi znaków, zmiennoprzecinkowe, obiekty Pythona itp.). Etykiety osi są zbiorczo nazywane indeksami.

pandy. serie

Serię pand można utworzyć za pomocą następującego konstruktora -

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

Parametry konstruktora są następujące -

Sr.No	Parametr i opis
1	data dane przybierają różne formy, takie jak ndarray, lista, stałe
2	index Wartości indeksu muszą być unikalne i możliwe do skasowania, a także mieć taką samą długość jak dane. Domyślnanp.arange(n) jeśli żaden indeks nie zostanie przekazany.
3	dtype dtype jest dla typu danych. Jeśli Brak, zostanie wywnioskowany typ danych
4	copy Skopiuj dane. Domyślnie False

Serię można utworzyć przy użyciu różnych danych wejściowych, takich jak -

Array
Dict
Wartość skalarna lub stała

Utwórz pustą serię

Podstawową serią, którą można stworzyć, jest seria pusta.

Przykład

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

Jego output wygląda następująco -

Series([], dtype: float64)

Utwórz serię z ndarray

Jeśli dane są tablicą ndarray, to przekazany indeks musi mieć taką samą długość. Jeśli żaden indeks nie zostanie przekazany, domyślnie indeks będzierange(n) gdzie n jest długością tablicy, tj. [0,1,2,3…. range(len(array))-1].

Przykład 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

Jego output wygląda następująco -

0   a
1   b
2   c
3   d
dtype: object

Nie przekazaliśmy żadnego indeksu, więc domyślnie przypisał indeksy z zakresu od 0 do len(data)-1czyli od 0 do 3.

Przykład 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

Jego output wygląda następująco -

100  a
101  b
102  c
103  d
dtype: object

Przekazaliśmy tutaj wartości indeksu. Teraz możemy zobaczyć dostosowane wartości indeksowane w danych wyjściowych.

Stwórz serię na podstawie dyktatu

ZA dictmożna przekazać jako dane wejściowe i jeśli nie określono indeksu, klucze słownika są brane w kolejności posortowanej w celu skonstruowania indeksu. Gdybyindex zostanie przekazana, wartości w danych odpowiadające etykietom w indeksie zostaną wyciągnięte.

Przykład 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

Jego output wygląda następująco -

a 0.0
b 1.0
c 2.0
dtype: float64

Observe - Klucze słownika służą do tworzenia indeksu.

Przykład 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

Jego output wygląda następująco -

b 1.0
c 2.0
d NaN
a 0.0
dtype: float64

Observe - Kolejność indeksów jest utrwalana, a brakujący element jest wypełniany wartością NaN (Not a Number).

Utwórz serię na podstawie skalara

Jeśli dane są wartością skalarną, należy podać indeks. Wartość zostanie powtórzona, aby dopasować długość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

Jego output wygląda następująco -

0  5
1  5
2  5
3  5
dtype: int64

Dostęp do danych z serii z pozycją

Dostęp do danych w serii można uzyskać podobnie jak w pliku ndarray.

Przykład 1

Pobierz pierwszy element. Jak już wiemy, że zaczyna liczyć od zera do tablicy, co oznacza, że pierwszy element jest przechowywany w temperaturze zera ^th pozycji i tak dalej.

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]

Jego output wygląda następująco -

Przykład 2

Odzyskaj pierwsze trzy elementy z serii. Jeśli przed nim zostanie wstawiony:, wszystkie elementy począwszy od tego indeksu zostaną wyodrębnione. Jeśli używane są dwa parametry (z: między nimi), elementy między dwoma indeksami (bez indeksu stop)

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]

Jego output wygląda następująco -

a  1
b  2
c  3
dtype: int64

Przykład 3

Odzyskaj ostatnie trzy elementy.

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:]

Jego output wygląda następująco -

c  3
d  4
e  5
dtype: int64

Pobierz dane za pomocą etykiety (indeksu)

Seria jest jak stała wielkość dict dzięki temu można pobierać i ustawiać wartości według etykiety indeksu.

Przykład 1

Pobierz pojedynczy element za pomocą wartości etykiety indeksu.

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']

Jego output wygląda następująco -

Przykład 2

Pobierz wiele elementów, korzystając z listy wartości etykiet indeksu.

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']]

Jego output wygląda następująco -

a  1
c  3
d  4
dtype: int64

Przykład 3

Jeśli etykieta nie jest zawarta, zgłaszany jest wyjątek.

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

#retrieve multiple elements
print s['f']

Jego output wygląda następująco -

…
KeyError: 'f'

Ramka danych to dwuwymiarowa struktura danych, tj. Dane są wyrównane tabelarycznie w wierszach i kolumnach.

Funkcje DataFrame

Potencjalnie kolumny są różnych typów
Rozmiar - zmienny
Oznakowane osie (wiersze i kolumny)
Potrafi wykonywać operacje arytmetyczne na wierszach i kolumnach

Struktura

Załóżmy, że tworzymy ramkę danych z danymi ucznia.

Możesz myśleć o tym jako o tabeli SQL lub reprezentacji danych w arkuszu kalkulacyjnym.

pandas.DataFrame

Pandy DataFrame można utworzyć za pomocą następującego konstruktora -

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

Parametry konstruktora są następujące -

Sr.No	Parametr i opis
1	data dane mają różne formy, takie jak ndarray, seria, mapa, listy, dykt, stałe, a także inna ramka DataFrame.
2	index W przypadku etykiet wierszy indeksem, który ma być użyty dla wynikowej ramki, jest opcjonalny domyślny np.arange (n), jeśli żaden indeks nie zostanie przekazany.
3	columns W przypadku etykiet kolumn opcjonalna składnia domyślna to - np.arange (n). Dzieje się tak tylko wtedy, gdy nie zostanie przekazany żaden indeks.
4	dtype Typ danych w każdej kolumnie.
5	copy To polecenie (lub cokolwiek to jest) jest używane do kopiowania danych, jeśli domyślną wartością jest False.

Utwórz DataFrame

Ramkę danych pandy można utworzyć przy użyciu różnych danych wejściowych, takich jak -

Lists
dict
Series
Numpy ndarrays
Inny DataFrame

W kolejnych sekcjach tego rozdziału zobaczymy, jak utworzyć ramkę DataFrame przy użyciu tych danych wejściowych.

Utwórz pustą ramkę danych

Podstawową ramką danych, którą można utworzyć, jest pusta ramka danych.

Przykład

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

Jego output wygląda następująco -

Empty DataFrame
Columns: []
Index: []

Utwórz DataFrame z list

Ramkę DataFrame można utworzyć za pomocą pojedynczej listy lub listy list.

Przykład 1

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

Jego output wygląda następująco -

Przykład 2

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

Jego output wygląda następująco -

Name      Age
0     Alex      10
1     Bob       12
2     Clarke    13

Przykład 3

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

Jego output wygląda następująco -

Name     Age
0     Alex     10.0
1     Bob      12.0
2     Clarke   13.0

Note - Obserwuj dtype parametr zmienia typ kolumny Age na zmiennoprzecinkową.

Utwórz DataFrame z Dict of ndarrays / Lists

Wszystkie ndarraysmusi mieć taką samą długość. Jeśli przekazano indeks, długość indeksu powinna być równa długości tablic.

Jeśli żaden indeks nie zostanie przekazany, domyślnie indeks będzie miał wartość range (n), gdzie n to długość tablicy.

Przykład 1

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

Jego output wygląda następująco -

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

Note- Przestrzegać wartości 0,1,2,3. Są to domyślne indeksy przypisane każdemu przy użyciu zakresu funkcji (n).

Przykład 2

Utwórzmy teraz indeksowaną ramkę DataFrame przy użyciu tablic.

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

Jego output wygląda następująco -

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

Note - Obserwuj index parametr przypisuje indeks do każdego wiersza.

Utwórz DataFrame z listy Dicts

Listę słowników można przekazać jako dane wejściowe w celu utworzenia ramki danych. Klucze słownika są domyślnie traktowane jako nazwy kolumn.

Przykład 1

Poniższy przykład pokazuje, jak utworzyć DataFrame, przekazując listę słowników.

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

Jego output wygląda następująco -

a    b      c
0   1   2     NaN
1   5   10   20.0

Note - Obserwuj, NaN (Not a Number) jest dodawany w brakujących obszarach.

Przykład 2

Poniższy przykład pokazuje, jak utworzyć DataFrame, przekazując listę słowników i indeksów wierszy.

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

Jego output wygląda następująco -

a   b       c
first   1   2     NaN
second  5   10   20.0

Przykład 3

Poniższy przykład pokazuje, jak utworzyć DataFrame z listą słowników, indeksów wierszy i indeksów kolumn.

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

Jego output wygląda następująco -

#df1 output
         a  b
first    1  2
second   5  10

#df2 output
         a  b1
first    1  NaN
second   5  NaN

Note- Obserwuj, df2 DataFrame jest tworzony z indeksem kolumny innym niż klucz słownika; w ten sposób dołączone NaN na miejscu. Podczas gdy df1 jest tworzony z indeksami kolumn takimi samymi jak klucze słownika, więc dołączane jest NaN.

Utwórz ramkę DataFrame z Dict of Series

Dictionary of Series można przekazać w celu utworzenia ramki DataFrame. Wynikowy indeks jest sumą wszystkich przekazanych indeksów serii.

Przykład

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

Jego output wygląda następująco -

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

Note - Zauważ, że w przypadku pierwszej serii nie ma etykiety ‘d’ przeszedł, ale w rezultacie dla d etykieta, NaN jest dodawane do NaN.

Zrozummy teraz column selection, addition, i deletion poprzez przykłady.

Wybór kolumny

Zrozumiemy to, wybierając kolumnę z DataFrame.

Przykład

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']

Jego output wygląda następująco -

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

Dodawanie kolumny

Zrozumiemy to, dodając nową kolumnę do istniejącej ramki danych.

Przykład

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

Jego output wygląda następująco -

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

Usunięcie kolumny

Kolumny można usuwać lub otwierać; weźmy przykład, aby zrozumieć, jak to zrobić.

Przykład

# 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

Jego output wygląda następująco -

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

Zaznaczanie, dodawanie i usuwanie wierszy

Teraz zrozumiemy zaznaczanie, dodawanie i usuwanie wierszy na podstawie przykładów. Zacznijmy od pojęcia selekcji.

Wybór według etykiety

Wiersze można wybrać, przekazując etykietę wiersza do pliku loc funkcjonować.

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']

Jego output wygląda następująco -

one 2.0
two 2.0
Name: b, dtype: float64

Rezultatem jest seria z etykietami jako nazwami kolumn DataFrame. Nazwa serii to etykieta, z którą została pobrana.

Wybór według lokalizacji całkowitej

Wiersze można wybrać, przekazując lokalizację całkowitą do pliku iloc funkcjonować.

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]

Jego output wygląda następująco -

one   3.0
two   3.0
Name: c, dtype: float64

Rzędy plasterków

Za pomocą operatora „:” można wybrać wiele wierszy.

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]

Jego output wygląda następująco -

one  two
c  3.0    3
d  NaN    4

Dodawanie wierszy

Dodaj nowe wiersze do DataFrame przy użyciu rozszerzenia appendfunkcjonować. Ta funkcja doda wiersze na końcu.

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

Jego output wygląda następująco -

Usunięcie wierszy

Użyj etykiety indeksu, aby usunąć lub upuścić wiersze z DataFrame. Jeśli etykieta jest zduplikowana, wiele wierszy zostanie usuniętych.

Jeśli zauważysz, w powyższym przykładzie etykiety są zduplikowane. Upuśćmy etykietę i zobaczymy, ile wierszy zostanie usuniętych.

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

Jego output wygląda następująco -

a b
1 3 4
1 7 8

W powyższym przykładzie dwa wiersze zostały usunięte, ponieważ te dwa zawierają tę samą etykietę 0.

ZA panelto trójwymiarowy kontener danych. TerminPanel data wywodzi się z ekonometrii i jest częściowo odpowiedzialny za nazwę pandy - pan(el)-da(ta)-s.

Nazwy 3 osi mają nadać znaczenie semantyczne opisowi operacji na danych panelowych. Oni są -

items - oś 0, każdy element odpowiada zawartej wewnątrz ramki DataFrame.
major_axis - oś 1, to indeks (wiersze) każdego elementu DataFrames.
minor_axis - oś 2, to kolumny każdej z ramek DataFrames.

pandas.Panel ()

Panel można utworzyć za pomocą następującego konstruktora -

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

Parametry konstruktora są następujące -

Parametr	Opis
dane	Dane przyjmują różne formy, takie jak ndarray, seria, mapa, listy, dykt, stałe, a także inna ramka DataFrame
przedmiotów	oś = 0
major_axis	oś = 1
minor_axis	oś = 2
dtype	Typ danych w każdej kolumnie
Kopiuj	Skopiuj dane. Domyślna,false

Utwórz panel

Panel można utworzyć na wiele sposobów, takich jak -

Od ndarrays
Z dyktatu DataFrames

Z 3D ndarray

# 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

Jego output wygląda następująco -

<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 - Zwróć uwagę na wymiary pustego panelu i panelu powyżej, wszystkie obiekty są różne.

Z dyktowania obiektów DataFrame

#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

Jego output wygląda następująco -

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

Utwórz pusty panel

Pusty panel można utworzyć za pomocą konstruktora Panel w następujący sposób -

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

Jego output wygląda następująco -

<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

Wybór danych z panelu

Wybierz dane z panelu za pomocą -

Items
Major_axis
Minor_axis

Korzystanie z przedmiotów

# 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']

Jego output wygląda następująco -

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

Mamy dwie pozycje i pobraliśmy item1. Rezultatem jest DataFrame z 4 wierszami i 3 kolumnami, które sąMajor_axis and Minor_axis dimensions.

Using major_axis

Data can be accessed using the method 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)

Its output is as follows −

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

Using minor_axis

Data can be accessed using the method 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)

Its output is as follows −

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

Note − Observe the changes in the dimensions.

By now, we learnt about the three Pandas DataStructures and how to create them. We will majorly focus on the DataFrame objects because of its importance in the real time data processing and also discuss a few other DataStructures.

Series Basic Functionality

Sr.No.	Attribute or Method & Description
1	axes Returns a list of the row axis labels
2	dtype Returns the dtype of the object.
3	empty Returns True if series is empty.
4	ndim Returns the number of dimensions of the underlying data, by definition 1.
5	size Returns the number of elements in the underlying data.
6	values Returns the Series as ndarray.
7	head() Returns the first n rows.
8	tail() Returns the last n rows.

Let us now create a Series and see all the above tabulated attributes operation.

Example

import pandas as pd
import numpy as np

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

Its output is as follows −

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

axes

Returns the list of the labels of the series.

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

Its output is as follows −

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

The above result is a compact format of a list of values from 0 to 5, i.e., [0,1,2,3,4].

empty

Returns the Boolean value saying whether the Object is empty or not. True indicates that the object is empty.

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

Its output is as follows −

Is the Object empty?
False

ndim

Returns the number of dimensions of the object. By definition, a Series is a 1D data structure, so it returns

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

Its output is as follows −

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

The dimensions of the object:
1

size

Returns the size(length) of the series.

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

Its output is as follows −

0   3.078058
1  -1.207803
dtype: float64

The size of the object:
2

values

Returns the actual data in the series as an array.

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

Its output is as follows −

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 ]

Head & Tail

To view a small sample of a Series or the DataFrame object, use the head() and the tail() methods.

head() returns the first n rows(observe the index values). The default number of elements to display is five, but you may pass a custom number.

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)

Its output is as follows −

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() returns the last n rows(observe the index values). The default number of elements to display is five, but you may pass a custom number.

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)

Its output is as follows −

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 Basic Functionality

Let us now understand what DataFrame Basic Functionality is. The following tables lists down the important attributes or methods that help in DataFrame Basic Functionality.

Sr.No.	Attribute or Method & Description
1	T Transposes rows and columns.
2	axes Returns a list with the row axis labels and column axis labels as the only members.
3	dtypes Returns the dtypes in this object.
4	empty True if NDFrame is entirely empty [no items]; if any of the axes are of length 0.
5	ndim Number of axes / array dimensions.
6	shape Returns a tuple representing the dimensionality of the DataFrame.
7	size Number of elements in the NDFrame.
8	values Numpy representation of NDFrame.
9	head() Returns the first n rows.
10	tail() Returns last n rows.

Let us now create a DataFrame and see all how the above mentioned attributes operate.

Example

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

Its output is as follows −

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 (Transpose)

Returns the transpose of the DataFrame. The rows and columns will interchange.

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

Its output is as follows −

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

axes

Returns the list of row axis labels and column axis labels.

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

Its output is as follows −

Row axis labels and column axis labels are:

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

dtypes

Returns the data type of each column.

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

Its output is as follows −

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

empty

Returns the Boolean value saying whether the Object is empty or not; True indicates that the object is empty.

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

Its output is as follows −

Is the object empty?
False

ndim

Returns the number of dimensions of the object. By definition, DataFrame is a 2D object.

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

Its output is as follows −

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

shape

Returns a tuple representing the dimensionality of the DataFrame. Tuple (a,b), where a represents the number of rows and b represents the number of columns.

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

Its output is as follows −

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)

size

Returns the number of elements in the DataFrame.

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

Its output is as follows −

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

values

Returns the actual data in the DataFrame as an 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

Its output is as follows −

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]]

Head & Tail

To view a small sample of a DataFrame object, use the head() and tail() methods. head() returns the first n rows (observe the index values). The default number of elements to display is five, but you may pass a custom number.

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)

Its output is as follows −

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() returns the last n rows (observe the index values). The default number of elements to display is five, but you may pass a custom number.

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)

Its output is as follows −

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

A large number of methods collectively compute descriptive statistics and other related operations on DataFrame. Most of these are aggregations like sum(), mean(), but some of them, like sumsum(), produce an object of the same size. Generally speaking, these methods take an axis argument, just like ndarray.{sum, std, ...}, but the axis can be specified by name or integer

DataFrame − “index” (axis=0, default), “columns” (axis=1)

Let us create a DataFrame and use this object throughout this chapter for all the operations.

Example

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

Its output is as follows −

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

sum()

Returns the sum of the values for the requested axis. By default, axis is index (axis=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()

Its output is as follows −

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

Each individual column is added individually (Strings are appended).

axis=1

This syntax will give the output as shown below.

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)

Jego output wygląda następująco -

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

oznaczać()

Zwraca średnią wartość

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()

Jego output wygląda następująco -

Age       31.833333
Rating     3.743333
dtype: float64

std ()

Zwraca odchylenie standardowe Bressela z kolumn liczbowych.

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()

Jego output wygląda następująco -

Age       9.232682
Rating    0.661628
dtype: float64

Funkcje i opis

Przyjrzyjmy się teraz funkcjom w sekcji Statystyki opisowe w Python Pandas. W poniższej tabeli wymieniono ważne funkcje -

Sr.No.	Funkcjonować	Opis
1	liczyć()	Liczba obserwacji niezerowych
2	suma()	Suma wartości
3	oznaczać()	Średnia wartości
4	mediana()	Mediana wartości
5	tryb()	Tryb wartości
6	std ()	Odchylenie standardowe wartości
7	min ()	Minimalna wartość
8	max ()	Maksymalna wartość
9	abs ()	Całkowita wartość
10	szturchać()	Produkt wartości
11	cumsum ()	Suma skumulowana
12	cumprod ()	Produkt zbiorczy

Note- Ponieważ DataFrame jest heterogeniczną strukturą danych. Operacje ogólne nie działają ze wszystkimi funkcjami.

Funkcje takie jak sum(), cumsum()działają z elementami danych liczbowymi i znakowymi (lub) bez żadnego błędu. Chociażn W praktyce agregacje znaków nie są generalnie używane, funkcje te nie zgłaszają żadnych wyjątków.
Funkcje takie jak abs(), cumprod() zgłoś wyjątek, gdy DataFrame zawiera dane znakowe lub ciągowe, ponieważ nie można wykonać takich operacji.

Podsumowanie danych

Plik describe() funkcja oblicza podsumowanie statystyk dotyczących kolumn DataFrame.

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()

Jego output wygląda następująco -

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

Ta funkcja daje mean, std i IQRwartości. Funkcja wyklucza kolumny znakowe i dane podsumowanie dotyczące kolumn numerycznych.'include'jest argumentem używanym do przekazywania niezbędnych informacji dotyczących kolumn, które należy uwzględnić przy podsumowaniu. Przyjmuje listę wartości; domyślnie „numer”.

object - Podsumowuje kolumny typu String
number - Podsumowuje kolumny liczbowe
all - Podsumowuje wszystkie kolumny razem (nie powinien przekazywać go jako wartości listy)

Teraz użyj poniższej instrukcji w programie i sprawdź dane wyjściowe -

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'])

Jego output wygląda następująco -

Name
count       12
unique      12
top      Ricky
freq         1

Teraz użyj poniższej instrukcji i sprawdź dane wyjściowe -

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')

Jego output wygląda następująco -

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

Aby zastosować funkcje własne lub innej biblioteki do obiektów Pandas, powinieneś być świadomy trzech ważnych metod. Metody zostały omówione poniżej. Odpowiednia metoda zależy od tego, czy funkcja ma działać na całym DataFrame, wierszach lub kolumnach, czy elementach.

Tabela mądry Zastosowanie funkcji: pipe ()
Aplikacja funkcji wiersza lub kolumny: zastosuj ()
Element mądry Aplikacja funkcji: applymap ()

Aplikacja funkcji tabelarycznej

Operacje niestandardowe można wykonać, przekazując funkcję i odpowiednią liczbę parametrów jako argumenty potoku. W ten sposób operacja jest wykonywana na całym DataFrame.

Na przykład dodaj wartość 2 do wszystkich elementów w DataFrame. Następnie,

funkcja sumatora

Funkcja sumująca dodaje dwie wartości liczbowe jako parametry i zwraca sumę.

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

Będziemy teraz używać funkcji niestandardowej do wykonywania operacji na DataFrame.

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

Zobaczmy pełny program -

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)

Jego output wygląda następująco -

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

Aplikacja funkcji wiersza lub kolumny

Arbitralne funkcje można stosować wzdłuż osi DataFrame lub Panel przy użyciu apply()metoda, która, podobnie jak opisowe metody statystyczne, przyjmuje opcjonalny argument osi. Domyślnie operacja jest wykonywana według kolumn, przyjmując każdą kolumnę jako tablicę.

Przykład 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)

Jego output wygląda następująco -

col1   -0.288022
col2    1.044839
col3   -0.187009
dtype: float64

Mijając axis parametr, operacje mogą być wykonywane wierszowo.

Przykład 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)

Jego output wygląda następująco -

col1    0.034093
col2   -0.152672
col3   -0.229728
dtype: float64

Przykład 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)

Jego output wygląda następująco -

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

Aplikacja funkcji Element Wise

Nie wszystkie funkcje można wektoryzować (ani tablice NumPy, które zwracają inną tablicę ani żadną wartość), metody applymap() w DataFrame i analogously map() on Series akceptuje każdą funkcję Pythona pobierającą jedną wartość i zwracającą jedną wartość.

Przykład 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)

Jego output wygląda następująco -

col1    0.480742
col2    0.454185
col3    0.266563
dtype: float64

Przykład 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)

Jego output wygląda następująco -

col1    0.395263
col2    0.204418
col3   -0.795188
dtype: float64

Reindexingzmienia etykiety wierszy i kolumn DataFrame. Aby reindex środki do zgodnych danych dopasować dany zestaw etykiet wzdłuż określonej osi.

Wiele operacji można wykonać poprzez indeksowanie, takie jak -

Zmień kolejność istniejących danych, aby dopasować je do nowego zestawu etykiet.
Wstaw znaczniki brakujących wartości (NA) w lokalizacjach etykiet, w których nie było danych dla etykiety.

Przykład

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

Jego output wygląda następująco -

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

Zindeksuj ponownie, aby wyrównać z innymi obiektami

Możesz chcieć wziąć obiekt i ponownie zindeksować jego osie, aby uzyskać taką samą etykietę jak inny obiekt. Rozważ następujący przykład, aby zrozumieć to samo.

Przykład

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

Jego output wygląda następująco -

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 - Tutaj df1 DataFrame jest zmieniana i reindeksowana jak df2. Nazwy kolumn powinny być dopasowane, w przeciwnym razie NAN zostanie dodane do całej etykiety kolumny.

Wypełnianie podczas ponownego indeksowania

reindex() przyjmuje opcjonalną metodę parametru, która jest metodą wypełniania z następującymi wartościami -

pad/ffill - Wypełnij wartości do przodu
bfill/backfill - Wypełnij wartości wstecz
nearest - Wypełnij od najbliższych wartości indeksu

Przykład

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')

Jego output wygląda następująco -

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 - Ostatnie cztery rzędy są wyściełane.

Ograniczenia dotyczące wypełniania podczas ponownego indeksowania

Argument limit zapewnia dodatkową kontrolę nad wypełnianiem podczas ponownego indeksowania. Limit określa maksymalną liczbę kolejnych dopasowań. Rozważmy następujący przykład, aby zrozumieć to samo -

Przykład

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)

Jego output wygląda następująco -

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- Zauważ, że tylko siódmy wiersz jest wypełniony przez poprzedni szósty wiersz. Następnie rzędy pozostawia się bez zmian.

Zmiana nazwy

Metoda rename () umożliwia zmianę etykiety osi na podstawie jakiegoś odwzorowania (dykt lub Seria) lub dowolnej funkcji.

Rozważmy następujący przykład, aby to zrozumieć -

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'})

Jego output wygląda następująco -

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

Metoda rename () zapewnia rozszerzenie inplacenazwany parametr, który domyślnie ma wartość False i kopiuje podstawowe dane. Przechodzićinplace=True aby zmienić nazwę danych w miejscu.

Zachowanie podstawowej iteracji na obiektach Pandas zależy od typu. Podczas iteracji po serii jest ona traktowana jako tablica, a podstawowa iteracja generuje wartości. Inne struktury danych, takie jak DataFrame i Panel, są zgodne zdict-like konwencja iteracji po keys obiektów.

Krótko mówiąc, podstawowa iteracja (dla i w obiekcie) produkuje -

Series - wartości
DataFrame - etykiety kolumn
Panel - etykiety przedmiotów

Iterowanie ramki DataFrame

Iteracja DataFrame daje nazwy kolumn. Rozważmy następujący przykład, aby zrozumieć to samo.

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

Jego output wygląda następująco -

A
C
D
x
y

Aby iterować po wierszach DataFrame, możemy użyć następujących funkcji -

iteritems() - iterować po parach (klucz, wartość)
iterrows() - iteruj po wierszach jako pary (indeks, seria)
itertuples() - iteruj po wierszach jako nazwane krotki

iteritems ()

Iteruje po każdej kolumnie jako klucz, para wartości z etykietą jako klucz i wartość kolumny jako obiekt Series.

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

Jego output wygląda następująco -

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

Zauważ, że każda kolumna jest iterowana osobno jako para klucz-wartość w serii.

iterrows ()

iterrows () zwraca iterator zwracający każdą wartość indeksu wraz z serią zawierającą dane w każdym wierszu.

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

Jego output wygląda następująco -

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 - Ponieważ iterrows()iteruje po wierszach, nie zachowuje typu danych w wierszu. 0,1,2 to indeksy wierszy, a col1, col2, col3 to indeksy kolumn.

itertuples ()

itertuples () zwróci iterator zwracający nazwaną krotkę dla każdego wiersza w DataFrame. Pierwszym elementem krotki będzie odpowiednia wartość indeksu wiersza, a pozostałe wartości to wartości wiersza.

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

Jego output wygląda następująco -

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- Nie próbuj modyfikować żadnego obiektu podczas iteracji. Iteracja jest przeznaczona do czytania, a iterator zwraca kopię oryginalnego obiektu (widoku), więc zmiany nie będą odzwierciedlać oryginalnego obiektu.

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

Jego output wygląda następująco -

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

Obserwuj, żadnych zmian nie widać.

W Pandas dostępne są dwa rodzaje sortowania. Oni są -

Według etykiety
Rzeczywista wartość

Rozważmy przykład z wyjściem.

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

Jego output wygląda następująco -

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

W unsorted_df, the labels i valuessą nieposortowane. Zobaczmy, jak można je posortować.

Według etykiety

Używając sort_index()metoda, przekazując argumenty osi i kolejność sortowania, można sortować DataFrame. Domyślnie sortowanie jest wykonywane na etykietach wierszy w kolejności rosnącej.

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

Jego output wygląda następująco -

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

Kolejność sortowania

Przekazując wartość logiczną do parametru rosnącego, można kontrolować kolejność sortowania. Rozważmy następujący przykład, aby zrozumieć to samo.

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

Jego output wygląda następująco -

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

Sortuj kolumny

Przekazując argument osi o wartości 0 lub 1, sortowanie można przeprowadzić na etykietach kolumn. Domyślnie axis = 0, sortuj według wiersza. Rozważmy następujący przykład, aby zrozumieć to samo.

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

Jego output wygląda następująco -

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

Według wartości

Jak sortowanie indeksów, sort_values()to metoda sortowania według wartości. Akceptuje argument „by”, który będzie używał nazwy kolumny DataFrame, z którą mają być sortowane wartości.

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

Jego output wygląda następująco -

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

Obserwuj, wartości col1 są sortowane, a odpowiednia wartość col2 i indeks wiersza będą się zmieniać wraz z col1. Dlatego wyglądają na niesortowane.

'by' argument przyjmuje listę wartości kolumn.

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

Jego output wygląda następująco -

Algorytm sortowania

sort_values()zapewnia możliwość wyboru algorytmu z łączenia, heapsort i quicksort. Mergesort to jedyny stabilny algorytm.

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

Jego output wygląda następująco -

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

W tym rozdziale omówimy operacje na łańcuchach z naszą podstawową serią / indeksem. W kolejnych rozdziałach nauczymy się, jak zastosować te funkcje łańcuchowe w DataFrame.

Pandas udostępnia zestaw funkcji tekstowych, które ułatwiają operowanie na danych łańcuchowych. Co najważniejsze, te funkcje ignorują (lub wykluczają) brakujące / NaN wartości.

Prawie wszystkie te metody działają z funkcjami tekstowymi w języku Python (patrz: https://docs.python.org/3/library/stdtypes.html#string-methods). Więc przekonwertuj obiekt Series na obiekt typu String, a następnie wykonaj operację.

Zobaczmy teraz, jak przebiega każda operacja.

Sr.No	Opis funkcji
1	lower() Konwertuje ciągi w Serii / Indeksie na małe litery.
2	upper() Konwertuje ciągi w Serii / Indeksie na wielkie litery.
3	len() Oblicza długość ciągu ().
4	strip() Pomaga usunąć białe znaki (w tym znak nowej linii) z każdego ciągu w serii / indeksie z obu stron.
5	split(' ') Dzieli każdy ciąg z podanym wzorem.
6	cat(sep=' ') Łączy elementy serii / indeksu z podanym separatorem.
7	get_dummies() Zwraca DataFrame z wartościami One-Hot Encoded.
8	contains(pattern) Zwraca wartość logiczną True dla każdego elementu, jeśli podciąg zawiera element, w przeciwnym razie False.
9	replace(a,b) Zastępuje wartość a z wartością b.
10	repeat(value) Powtarza każdy element określoną liczbę razy.
11	count(pattern) Zwraca liczbę pojawiania się wzorca w każdym elemencie.
12	startswith(pattern) Zwraca wartość true, jeśli element w serii / indeksie zaczyna się od wzorca.
13	endswith(pattern) Zwraca wartość true, jeśli element w serii / indeksie kończy się wzorem.
14	find(pattern) Zwraca pierwszą pozycję pierwszego wystąpienia wzorca.
15	findall(pattern) Zwraca listę wszystkich wystąpień wzorca.
16	swapcase Zamienia małe / duże litery.
17	islower() Sprawdza, czy wszystkie znaki w każdym ciągu w serii / indeksie są małymi literami, czy nie. Zwraca wartość logiczną
18	isupper() Sprawdza, czy wszystkie znaki w każdym ciągu w serii / indeksie są dużymi literami, czy nie. Zwraca wartość logiczną.
19	isnumeric() Sprawdza, czy wszystkie znaki w każdym ciągu w serii / indeksie są numeryczne. Zwraca wartość logiczną.

Stwórzmy teraz serię i zobaczmy, jak działają wszystkie powyższe funkcje.

import pandas as pd
import numpy as np

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

print s

Jego output wygląda następująco -

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

niższy()

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()

Jego output wygląda następująco -

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

górny()

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()

Jego output wygląda następująco -

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()

Jego output wygląda następująco -

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

rozebrać się()

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()

Jego output wygląda następująco -

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

podział (wzór)

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(' ')

Jego output wygląda następująco -

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

kot (sep = wzór)

import pandas as pd
import numpy as np

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

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

Jego output wygląda następująco -

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()

Jego output wygląda następująco -

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

zawiera ()

import pandas as pd

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

print s.str.contains(' ')

Jego output wygląda następująco -

0   True
1   True
2   False
3   False
dtype: bool

wymienić (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('@','$')

Jego output wygląda następująco -

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

powtórzyć (wartość)

import pandas as pd

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

print s.str.repeat(2)

Jego output wygląda następująco -

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

count (wzorzec)

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')

Jego output wygląda następująco -

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

zaczyna się (wzór)

import pandas as pd

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

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

Jego output wygląda następująco -

0  True
1  False
2  False
3  False
dtype: bool

endwith (wzór)

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

Jego output wygląda następująco -

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

znajdź (wzór)

import pandas as pd

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

print s.str.find('e')

Jego output wygląda następująco -

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

„-1” oznacza, że w elemencie nie ma takiego wzorca.

findall (wzór)

import pandas as pd

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

print s.str.findall('e')

Jego output wygląda następująco -

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

Lista pusta ([]) wskazuje, że w elemencie nie ma takiego wzorca.

swapcase ()

import pandas as pd

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

Jego output wygląda następująco -

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()

Jego output wygląda następująco -

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()

Jego output wygląda następująco -

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()

Jego output wygląda następująco -

0  False
1  False
2  False
3  False
dtype: bool

Pandy zapewniają API do dostosowywania niektórych aspektów jego zachowania, najczęściej używany jest wyświetlacz.

API składa się z pięciu odpowiednich funkcji. Oni są -

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

Zrozummy teraz, jak działają te funkcje.

get_option (parametr)

get_option przyjmuje pojedynczy parametr i zwraca wartość podaną w danych wyjściowych poniżej -

display.max_rows

Wyświetla domyślną liczbę wartości. Interpreter odczytuje tę wartość i wyświetla wiersze z tą wartością jako górną granicą do wyświetlenia.

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

Jego output wygląda następująco -

display.max_columns

Wyświetla domyślną liczbę wartości. Interpreter odczytuje tę wartość i wyświetla wiersze z tą wartością jako górną granicą do wyświetlenia.

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

Jego output wygląda następująco -

Tutaj 60 i 20 to domyślne wartości parametrów konfiguracyjnych.

set_option (parametr, wartość)

set_option przyjmuje dwa argumenty i ustawia wartość na parametr, jak pokazano poniżej -

display.max_rows

Za pomocą set_option(), możemy zmienić domyślną liczbę wyświetlanych wierszy.

import pandas as pd

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

print pd.get_option("display.max_rows")

Jego output wygląda następująco -

display.max_columns

Za pomocą set_option(), możemy zmienić domyślną liczbę wyświetlanych wierszy.

import pandas as pd

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

print pd.get_option("display.max_columns")

Jego output wygląda następująco -

reset_option (parametr)

reset_option przyjmuje argument i ustawia wartość z powrotem na wartość domyślną.

display.max_rows

Używając reset_option (), możemy zmienić wartość z powrotem na domyślną liczbę wyświetlanych wierszy.

import pandas as pd

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

Jego output wygląda następująco -

opisać_opcję (parametr)

describe_option wypisuje opis argumentu.

display.max_rows

Używając reset_option (), możemy zmienić wartość z powrotem na domyślną liczbę wyświetlanych wierszy.

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

Jego output wygląda następująco -

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 ()

menadżer kontekstu option_context służy do ustawiania opcji w with statementtymczasowo. Wartości opcji są przywracane automatycznie po wyjściu zwith block -

display.max_rows

Używając option_context (), możemy tymczasowo ustawić wartość.

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"))

Jego output wygląda następująco -

10
10

Zobacz różnicę między pierwszą a drugą instrukcją print. Pierwsza instrukcja wyświetla wartość ustawioną przezoption_context() który jest tymczasowy w with contextsamo. Powith context, druga instrukcja print drukuje skonfigurowaną wartość.

Często używane parametry

Sr.No	Parametr i opis
1	display.max_rows Wyświetla maksymalną liczbę wierszy do wyświetlenia
2	2 display.max_columns Wyświetla maksymalną liczbę kolumn do wyświetlenia
3	display.expand_frame_repr Wyświetla ramki danych do rozciągniętych stron
4	display.max_colwidth Wyświetla maksymalną szerokość kolumny
5	display.precision Wyświetla dokładność liczb dziesiętnych

W tym rozdziale omówimy, jak wyciąć i pokroić w kostkę datę i ogólnie uzyskać podzbiór obiektu pandy.

Operatory indeksowania Python i NumPy „[]” oraz operator atrybutów „.” zapewniają szybki i łatwy dostęp do struktur danych Pandas w szerokim zakresie przypadków użycia. Ponieważ jednak typ danych, do których można uzyskać dostęp, nie jest z góry znany, bezpośrednie korzystanie ze standardowych operatorów ma pewne ograniczenia dotyczące optymalizacji. W przypadku kodu produkcyjnego zalecamy skorzystanie ze zoptymalizowanych metod dostępu do danych pand, które zostały wyjaśnione w tym rozdziale.

Pandy obsługują teraz trzy typy indeksowania wieloosiowego; trzy typy są wymienione w poniższej tabeli -

Sr.No	Indeksowanie i opis
1	.loc() Na podstawie etykiety
2	.iloc() Oparte na liczbach całkowitych
3	.ix() Oparte na etykietach i liczbach całkowitych

.loc ()

Pandy zapewniają różne metody czystego posiadania label based indexing. Podczas krojenia dołączana jest również granica początkowa. Liczby całkowite są prawidłowymi etykietami, ale odnoszą się do etykiety, a nie do pozycji.

.loc() ma wiele metod dostępu, takich jak -

Pojedyncza etykieta skalarna
Lista etykiet
Obiekt plasterek
Tablica boolowska

locprzyjmuje dwa pojedyncze operatory / lista / zakres oddzielone znakiem „,”. Pierwsza wskazuje rząd, a druga kolumny.

Przykład 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']

Jego output wygląda następująco -

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

Przykład 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']]

Jego output wygląda następująco -

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

Przykład 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']]

Jego output wygląda następująco -

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

Przykład 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']

Jego output wygląda następująco -

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

Przykład 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

Jego output wygląda następująco -

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

.I loc()

Pandy zapewniają różne metody, aby uzyskać indeksowanie oparte wyłącznie na liczbach całkowitych. Podobnie jak Python i Numpy, są0-based indeksowanie.

Różne metody dostępu są następujące -

Liczba całkowita
Lista liczb całkowitych
Zakres wartości

Przykład 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]

Jego output wygląda następująco -

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

Przykład 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]

Jego output wygląda następująco -

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

Przykład 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]

Jego output wygląda następująco -

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 ()

Oprócz czystych etykiet i liczb całkowitych, Pandas zapewnia hybrydową metodę selekcji i podzbioru obiektu za pomocą operatora .ix ().

Przykład 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]

Jego output wygląda następująco -

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

Przykład 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']

Jego output wygląda następująco -

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

Stosowanie notacji

Pobieranie wartości z obiektu Pandas z indeksowaniem wieloosiowym wykorzystuje następującą notację -

Obiekt	Indeksatory	Typ zwrotu
Seria	s.loc [indeksator]	Wartość skalarna
Ramka danych	df.loc [row_index, col_index]	Obiekt serii
Płyta	p.loc [item_index, major_index, minor_index]	p.loc [item_index, major_index, minor_index]

Note − .iloc() & .ix() stosuje te same opcje indeksowania i wartość zwracaną.

Zobaczmy teraz, jak każdą operację można wykonać na obiekcie DataFrame. Użyjemy podstawowego operatora indeksowania „[]” -

Przykład 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']

Jego output wygląda następująco -

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 - Możemy przekazać listę wartości do [], aby wybrać te kolumny.

Przykład 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']]

Jego output wygląda następująco -

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

Przykład 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]

Jego output wygląda następująco -

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

Dostęp do atrybutów

Kolumny można wybierać za pomocą operatora atrybutu „.”.

Przykład

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

print df.A

Jego output wygląda następująco -

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

Metody statystyczne pomagają w zrozumieniu i analizie zachowania danych. Nauczymy się teraz kilku funkcji statystycznych, które możemy zastosować na obiektach Pandy.

Percent_change

Serie, ramki danych i panel - wszystkie mają tę funkcję pct_change(). Ta funkcja porównuje każdy element z jego poprzednim elementem i oblicza procentową zmianę.

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()

Jego output wygląda następująco -

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

Domyślnie pct_change()działa na kolumnach; jeśli chcesz zastosować ten sam wiersz mądrze, użyjaxis=1() argument.

Kowariancja

Kowariancja jest stosowana do danych szeregowych. Obiekt Series ma metodę cov obliczającą kowariancję między obiektami serii. NA zostanie automatycznie wykluczona.

Seria Cov

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)

Jego output wygląda następująco -

-0.12978405324

Metoda kowariancji, gdy jest stosowana w DataFrame, oblicza cov między wszystkimi kolumnami.

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()

Jego output wygląda następująco -

-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 - Obserwuj cov pomiędzy a i b kolumna w pierwszej instrukcji i to samo jest wartością zwracaną przez cov w DataFrame.

Korelacja

Korelacja przedstawia liniową zależność między dowolnymi dwoma tablicami wartości (szeregami). Istnieje wiele metod obliczania korelacji, takich jak pearson (domyślnie), spearman i kendall.

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()

Jego output wygląda następująco -

-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

Jeśli jakakolwiek nieliczbowa kolumna jest obecna w DataFrame, jest automatycznie wykluczana.

Ranking danych

Ranking danych tworzy ranking dla każdego elementu w tablicy elementów. W przypadku remisów przypisuje średnią rangę.

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()

Jego output wygląda następująco -

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

Ranga opcjonalnie przyjmuje parametr rosnący, który domyślnie ma wartość true; jeśli fałsz, dane są klasyfikowane w kolejności odwrotnej, a większe wartości mają niższą rangę.

Rank obsługuje różne metody rozstrzygające, określone za pomocą parametru metody -

average - średnia ranga zremisowanej grupy
min - najniższa pozycja w grupie
max - najwyższa pozycja w grupie
first - rangi przypisane w kolejności, w jakiej pojawiają się w tablicy

Do pracy z danymi liczbowymi, Pandy zapewniają kilka wariantów, takich jak przewijanie, rozwijanie i wykładniczo przesuwające się wagi dla statystyk okien. Wśród nich sąsum, mean, median, variance, covariance, correlation, itp.

Dowiemy się teraz, jak każdy z nich można zastosować do obiektów DataFrame.

.rolling () Funkcja

Tę funkcję można zastosować do serii danych. Określićwindow=n argument i zastosuj na jego wierzchu odpowiednią funkcję statystyczną.

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()

Jego output wygląda następująco -

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 - Ponieważ rozmiar okna wynosi 3, dla pierwszych dwóch elementów są wartości zerowe, a od trzeciego wartość będzie średnią n, n-1 i n-2elementy. W ten sposób możemy również zastosować różne funkcje, jak wspomniano powyżej.

.expanding (), funkcja

Tę funkcję można zastosować do serii danych. Określićmin_periods=n argument i zastosuj na jego wierzchu odpowiednią funkcję statystyczną.

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()

Jego output wygląda następująco -

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 () Funkcja

ewmjest stosowany do serii danych. Podaj dowolne z com, span,halflifeargument i zastosuj na wierzchu odpowiednią funkcję statystyczną. Przypisuje wagi wykładniczo.

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()

Jego output wygląda następująco -

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

Funkcje okna są głównie używane do graficznego znajdowania trendów w danych poprzez wygładzanie krzywej. Jeśli codzienne dane są bardzo zróżnicowane i dostępnych jest wiele punktów danych, jedną metodą jest pobranie próbek i wykreślenie, a inną metodą jest zastosowanie obliczeń w oknie i wykreślenie wykresu na wynikach. Tymi metodami możemy wygładzić krzywą lub trend.

Po zwijaniu, rozszerzaniu i ewm obiektów, dostępnych jest kilka metod wykonywania agregacji danych.

Stosowanie agregacji w DataFrame

Stwórzmy DataFrame i zastosujmy na niej agregacje.

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

Jego output wygląda następująco -

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]

Możemy agregować, przekazując funkcję do całej ramki DataFrame lub wybrać kolumnę za pośrednictwem standardu get item metoda.

Zastosuj agregację do całej ramki danych

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)

Jego output wygląda następująco -

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

Zastosuj agregację do pojedynczej kolumny ramki danych

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)

Jego output wygląda następująco -

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

Zastosuj agregację w wielu kolumnach ramki danych

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)

Jego output wygląda następująco -

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

Zastosuj wiele funkcji w jednej kolumnie DataFrame

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])

Jego output wygląda następująco -

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

Zastosuj wiele funkcji w wielu kolumnach ramki danych

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])

Jego output wygląda następująco -

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

Zastosuj różne funkcje do różnych kolumn ramki danych

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})

Jego output wygląda następująco -

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

Brakujące dane są zawsze problemem w rzeczywistych scenariuszach. Obszary takie jak uczenie maszynowe i eksploracja danych borykają się z poważnymi problemami z dokładnością prognoz modelu z powodu niskiej jakości danych spowodowanej brakującymi wartościami. W tych obszarach traktowanie brakujących wartości jest głównym punktem zainteresowania, aby ich modele były dokładniejsze i bardziej aktualne.

Kiedy i dlaczego brakuje danych?

Rozważmy ankietę internetową dotyczącą produktu. Często ludzie nie udostępniają wszystkich związanych z nimi informacji. Niewiele osób dzieli się swoimi doświadczeniami, ale nie dotyczy to tego, jak długo używają produktu; niewiele osób dzieli się tym, jak długo używają produktu, swoimi doświadczeniami, ale nie swoimi danymi kontaktowymi. W ten sposób zawsze brakuje części danych, co jest bardzo powszechne w czasie rzeczywistym.

Zobaczmy teraz, jak możemy obsłużyć brakujące wartości (powiedzmy NA lub NaN) za pomocą Pand.

# 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

Jego output wygląda następująco -

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

Korzystając z reindeksowania, utworzyliśmy DataFrame z brakami danych. Na wyjściuNaN znaczy Not a Number.

Sprawdź brakujące wartości

Aby ułatwić wykrywanie brakujących wartości (i dla różnych typów tablic), Pandas udostępnia rozszerzenie isnull() i notnull() funkcje, które są również metodami w obiektach Series i DataFrame -

Przykład 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()

Jego output wygląda następująco -

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

Przykład 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()

Jego output wygląda następująco -

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

Obliczenia z brakującymi danymi

Podczas sumowania danych NA będzie traktowane jako zero
Jeśli wszystkie dane to NA, wynikiem będzie NA

Przykład 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()

Jego output wygląda następująco -

2.02357685917

Przykład 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()

Jego output wygląda następująco -

nan

Czyszczenie / uzupełnianie brakujących danych

Pandy zapewniają różne metody czyszczenia brakujących wartości. Funkcja fillna może „wypełnić” wartości NA danymi niezerowymi na kilka sposobów, które zilustrowaliśmy w kolejnych sekcjach.

Zastąp NaN wartością skalarną

Poniższy program pokazuje, jak zamienić „NaN” na „0”.

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)

Jego output wygląda następująco -

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

Tutaj wypełniamy wartością zero; zamiast tego możemy również wypełnić dowolną inną wartością.

Wypełnij NA do przodu i do tyłu

Wykorzystując koncepcje wypełniania omówione w rozdziale o indeksowaniu, uzupełnimy brakujące wartości.

Sr.No	Metoda i działanie
1	pad/fill Metody wypełnienia Forward
2	bfill/backfill Metody wypełniania Wstecz

Przykład 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')

Jego output wygląda następująco -

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

Przykład 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')

Jego output wygląda następująco -

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

Usuń brakujące wartości

Jeśli chcesz po prostu wykluczyć brakujące wartości, użyj dropna funkcja wraz z axisargument. Domyślnie oś = 0, tj. Wzdłuż wiersza, co oznacza, że jeśli jakakolwiek wartość w wierszu to NA, cały wiersz jest wykluczony.

Przykład 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()

Jego output wygląda następująco -

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

Przykład 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)

Jego output wygląda następująco -

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

Zastąp brakujące (lub) wartości ogólne

Często musimy zastąpić wartość ogólną jakąś określoną wartością. Możemy to osiągnąć stosując metodę zamiany.

Zastąpienie NA wartością skalarną jest równoważnym zachowaniem fillna() funkcjonować.

Przykład 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})

Jego output wygląda następująco -

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

Przykład 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})

Jego output wygląda następująco -

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

Każdy groupbyoperacja obejmuje jedną z następujących operacji na oryginalnym obiekcie. Oni są -

Splitting obiekt
Applying funkcja
Combining wyniki

W wielu sytuacjach dzielimy dane na zbiory i stosujemy pewne funkcje w każdym podzbiorze. W zastosowanej funkcjonalności możemy wykonać następujące operacje -

Aggregation - obliczanie statystyki podsumowującej
Transformation - wykonać jakąś operację specyficzną dla grupy
Filtration - odrzucenie danych pod pewnymi warunkami

Stwórzmy teraz obiekt DataFrame i wykonaj na nim wszystkie operacje -

#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

Jego output wygląda następująco -

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

Podziel dane na grupy

Obiekt Pandy można podzielić na dowolne z ich obiektów. Istnieje wiele sposobów podziału obiektu, na przykład -

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

Zobaczmy teraz, jak obiekty grupujące można zastosować do obiektu DataFrame

Przykład

# 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')

Jego output wygląda następująco -

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

Wyświetl grupy

# 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

Jego output wygląda następująco -

{'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')}

Przykład

Group by z wieloma kolumnami -

# 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

Jego output wygląda następująco -

{('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')}

Iterowanie po grupach

Dzięki groupby obiekt w ręku, możemy iterować przez obiekt podobny do itertools.obj.

# 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

Jego output wygląda następująco -

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

Domyślnie groupby obiekt ma taką samą nazwę etykiety jak nazwa grupy.

Wybierz grupę

Używając get_group() możemy wybrać jedną grupę.

# 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)

Jego output wygląda następująco -

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

Agregacje

Zagregowana funkcja zwraca jedną zagregowaną wartość dla każdej grupy. Kiedyśgroup by obiektu, na zgrupowanych danych można wykonać kilka operacji agregacji.

Oczywistym jest agregacja za pośrednictwem agregatu lub odpowiednika agg metoda -

# 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)

Jego output wygląda następująco -

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

Innym sposobem sprawdzenia rozmiaru każdej grupy jest zastosowanie funkcji size () -

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)

Jego output wygląda następująco -

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

Jednoczesne stosowanie wielu funkcji agregujących

W przypadku serii zgrupowanych możesz również zaliczyć list lub dict of functions wykonać agregację i wygenerować DataFrame jako dane wyjściowe -

# 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])

Jego output wygląda następująco -

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

Transformacje

Transformacja grupy lub kolumny zwraca obiekt indeksowany o takim samym rozmiarze, jaki jest grupowany. W związku z tym transformacja powinna zwrócić wynik, który ma taki sam rozmiar, jak rozmiar fragmentu grupy.

# 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)

Jego output wygląda następująco -

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

Filtrowanie

Filtracja filtruje dane według zdefiniowanych kryteriów i zwraca podzbiór danych. Plikfilter() funkcja służy do filtrowania danych.

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)

Jego output wygląda następująco -

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

W powyższym warunku filtru prosimy o zwrócenie drużyn, które uczestniczyły trzy lub więcej razy w IPL.

Pandas ma w pełni funkcjonalne, wysokowydajne operacje łączenia w pamięci, idiomatycznie bardzo podobne do relacyjnych baz danych, takich jak SQL.

Pandy zapewniają jedną funkcję, merge, jako punkt wejścia dla wszystkich standardowych operacji łączenia bazy danych między obiektami DataFrame -

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

Tutaj użyliśmy następujących parametrów -

left - Obiekt DataFrame.
right - Kolejny obiekt DataFrame.
on- Kolumny (nazwy) do przyłączenia się. Musi znajdować się zarówno w lewym, jak i prawym obiekcie DataFrame.
left_on- Kolumny z lewej ramki DataFrame do użycia jako klucze. Mogą to być nazwy kolumn lub tablice o długości równej długości DataFrame.
right_on- Kolumny z prawej ramki DataFrame do użycia jako klucze. Mogą to być nazwy kolumn lub tablice o długości równej długości DataFrame.
left_index - Jeśli True,użyj indeksu (etykiet wierszy) z lewej ramki DataFrame jako jego kluczy łączenia. W przypadku ramki DataFrame z MultiIndex (hierarchiczna) liczba poziomów musi odpowiadać liczbie kluczy łączenia z prawej ramki DataFrame.
right_index - To samo użycie co left_index dla właściwej ramki DataFrame.
how- Jedno z „lewej”, „prawej”, „zewnętrznej”, „wewnętrznej”. Domyślnie wewnętrzna. Każda metoda została opisana poniżej.
sort- Sortuj wynik DataFrame według kluczy łączenia w porządku leksykograficznym. Domyślnie True, ustawienie False znacznie poprawi wydajność w wielu przypadkach.

Utwórzmy teraz dwie różne ramki DataFrame i wykonaj na nich operacje scalania.

# 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

Jego output wygląda następująco -

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

Scal dwie ramki danych na kluczu

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')

Jego output wygląda następująco -

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

Scal dwie ramki danych na wielu kluczach

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'])

Jego output wygląda następująco -

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

Scal za pomocą argumentu „jak”

Plik howargument do scalenia określa, jak określić, które klucze mają zostać uwzględnione w tabeli wynikowej. Jeśli kombinacja klawiszy nie pojawia się w lewej ani w prawej tabeli, wartości w połączonej tabeli będą miały wartość NA.

Oto podsumowanie how opcje i ich odpowiedniki w SQL -

Metoda scalania	Odpowiednik SQL	Opis
lewo	LEWE POŁĄCZENIE ZEWNĘTRZNE	Użyj klawiszy z lewego obiektu
dobrze	PRAWE ZEWNĘTRZNE POŁĄCZENIE	Użyj kluczy z odpowiedniego obiektu
zewnętrzny	PEŁNE POŁĄCZENIE ZEWNĘTRZNE	Użyj unii kluczy
wewnętrzny	WEWNĘTRZNE DOŁĄCZENIE	Użyj przecięcia kluczy

Left Join

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')

Jego output wygląda następująco -

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

Right Join

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')

Jego output wygląda następująco -

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

Połączenie zewnętrzne

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')

Jego output wygląda następująco -

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

Połączenie wewnętrzne

Łączenie nastąpi na indeksie. Operacja Join honoruje obiekt, na którym jest wywoływana. Więc,a.join(b) nie jest równe 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')

Jego output wygląda następująco -

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

Pandy zapewniają różne udogodnienia do łatwego łączenia Series, DataFrame, i Panel obiekty.

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

objs - To jest sekwencja lub mapowanie obiektów Series, DataFrame lub Panel.
axis - {0, 1, ...}, domyślnie 0. To jest oś do połączenia.
join- {'wewnętrzny', 'zewnętrzny'}, domyślny 'zewnętrzny'. Jak obsługiwać indeksy na innych osiach. Zewnętrzna do połączenia i wewnętrzna do przecięcia.
ignore_index- boolean, domyślnie False. Jeśli True, nie używaj wartości indeksu na osi konkatenacji. Wynikowa oś zostanie oznaczona jako 0, ..., n - 1.
join_axes- To jest lista obiektów indeksu. Określone indeksy do użycia dla innych (n-1) osi zamiast wykonywania wewnętrznej / zewnętrznej logiki zbioru.

Łączenie obiektów

Plik concatfunkcja wykonuje wszystkie ciężkie czynności związane z wykonywaniem operacji konkatenacji wzdłuż osi. Stwórzmy różne obiekty i zróbmy konkatenację.

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])

Jego output wygląda następująco -

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

Załóżmy, że chcieliśmy skojarzyć określone klucze z każdym fragmentem pociętej ramki DataFrame. Możemy to zrobić za pomocąkeys argument -

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'])

Jego output wygląda następująco -

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

Indeks wyniku jest zduplikowany; każdy indeks jest powtarzany.

Jeśli wynikowy obiekt ma podlegać własnemu indeksowaniu, ustaw ignore_index do 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)

Jego output wygląda następująco -

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

Obserwuj, indeks zmienia się całkowicie, a klucze również są nadpisywane.

Jeśli trzeba dodać dwa obiekty axis=1, to nowe kolumny zostaną dołączone.

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)

Jego output wygląda następująco -

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

Łączenie przy użyciu append

Przydatnym skrótem do konkatacji są metody dołączania instancji w Series i DataFrame. Te metody faktycznie poprzedziły konkat. Łączą się razemaxis=0czyli indeks -

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)

Jego output wygląda następująco -

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

Plik append funkcja może również przyjmować wiele obiektów -

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])

Jego output wygląda następująco -

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

Szereg czasowy

Pandy zapewniają solidne narzędzie do czasu pracy z danymi szeregów czasowych, szczególnie w sektorze finansowym. Podczas pracy z danymi szeregów czasowych często napotykamy:

Generowanie sekwencji czasu
Konwertuj szeregi czasowe na różne częstotliwości

Pandy zapewnia stosunkowo kompaktowy i samodzielny zestaw narzędzi do wykonywania powyższych zadań.

Pobierz aktualny czas

datetime.now() podaje aktualną datę i godzinę.

import pandas as pd

print pd.datetime.now()

Jego output wygląda następująco -

2017-05-11 06:10:13.393147

Utwórz znacznik czasu

Dane ze znacznikiem czasu to najbardziej podstawowy typ danych z serii czasowej, który kojarzy wartości z punktami w czasie. W przypadku obiektów pandy oznacza to wykorzystanie punktów w czasie. Weźmy przykład -

import pandas as pd

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

Jego output wygląda następująco -

2017-03-01 00:00:00

Możliwa jest również konwersja liczb całkowitych lub zmiennoprzecinkowych. Domyślną jednostką dla tego są nanosekundy (ponieważ tak są przechowywane znaczniki czasu). Jednak często epoki są przechowywane w innej jednostce, którą można określić. Weźmy inny przykład

import pandas as pd

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

Jego output wygląda następująco -

2020-04-24 00:14:15

Utwórz zakres czasu

import pandas as pd

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

Jego output wygląda następująco -

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

Zmień częstotliwość czasu

import pandas as pd

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

Jego output wygląda następująco -

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

Konwertowanie na znaczniki czasu

Aby przekonwertować serię lub obiekt typu lista obiektów typu daty, na przykład ciągów znaków, epok lub ich mieszanki, możesz użyć to_datetimefunkcjonować. Po przekazaniu zwraca Series (z tym samym indeksem), podczas gdy alist-like jest konwertowany na DatetimeIndex. Spójrz na następujący przykład -

import pandas as pd

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

Jego output wygląda następująco -

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

NaT znaczy Not a Time (odpowiednik NaN)

Weźmy inny przykład.

import pandas as pd

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

Jego output wygląda następująco -

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

Rozszerzając szereg czasowy, funkcjonalności Data odgrywają istotną rolę w analizie danych finansowych. Podczas pracy z danymi typu Date często napotykamy:

Generowanie sekwencji dat
Konwertuj serie dat na różne częstotliwości

Utwórz zakres dat

Używając date.range()funkcji, określając okresy i częstotliwość, możemy utworzyć serie dat. Domyślna częstotliwość zakresu to dni.

import pandas as pd

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

Jego output wygląda następująco -

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

Zmień częstotliwość dat

import pandas as pd

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

Jego output wygląda następująco -

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 () oznacza zakresy dat biznesowych. W przeciwieństwie do date_range () wyklucza sobotę i niedzielę.

import pandas as pd

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

Jego output wygląda następująco -

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

Zauważ, że po 3 marca data przeskakuje do 6 marca z wyłączeniem 4 i 5 marca. Po prostu sprawdź dni w kalendarzu.

Wygodne funkcje, takie jak date_range i bdate_rangewykorzystują różne aliasy częstotliwości. Domyślną częstotliwością dla date_range jest dzień kalendarzowy, a domyślną dla bdate_range jest dzień roboczy.

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

print pd.date_range(start, end)

Jego output wygląda następująco -

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

Odsuń aliasy

Kilka aliasów łańcuchów jest przypisanych do użytecznych wspólnych częstotliwości szeregów czasowych. Będziemy nazywać te aliasy jako przesunięte aliasy.

Alias	Opis	Alias	Opis
b	częstotliwość dni roboczych	BQS	częstotliwość rozpoczęcia kwartału biznesowego
re	częstotliwość dni kalendarzowych	ZA	roczna (roczna) częstotliwość końcowa
W.	częstotliwość tygodniowa	BA	częstotliwość zakończenia roku obrotowego
M	częstotliwość na koniec miesiąca	BAS	częstotliwość rozpoczęcia roku obrotowego
SM	częstotliwość co pół miesiąca	BH	częstotliwość godzin pracy
BM	częstotliwość zakończenia miesiąca roboczego	H.	częstotliwość godzinowa
SM	miesięczna częstotliwość początkowa	T, min	częstotliwość minutowa
SMS	Częstotliwość wysyłania wiadomości SMS co pół miesiąca	S	druga częstotliwość
BMS	częstotliwość rozpoczęcia miesiąca roboczego	L, ms	milisekund
Q	częstotliwość na koniec kwartału	U nas	mikrosekundy
BQ	częstotliwość na koniec kwartału biznesowego	N	nanosekund
QS	częstotliwość rozpoczęcia kwartału

Czasy to różnice w czasie wyrażone w jednostkach różnic, na przykład dni, godziny, minuty, sekundy. Mogą być zarówno pozytywne, jak i negatywne.

Możemy tworzyć obiekty Timedelta przy użyciu różnych argumentów, jak pokazano poniżej -

Strunowy

Przekazując ciąg znaków, możemy stworzyć obiekt timedelta.

import pandas as pd

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

Jego output wygląda następująco -

2 days 02:15:30

Liczba całkowita

Przekazując wartość całkowitą z jednostką, argument tworzy obiekt Timedelta.

import pandas as pd

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

Jego output wygląda następująco -

0 days 06:00:00

Przesunięcia danych

W budownictwie można również wykorzystać przesunięcia danych, takie jak - tygodnie, dni, godziny, minuty, sekundy, milisekundy, mikrosekundy, nanosekundy.

import pandas as pd

print pd.Timedelta(days=2)

Jego output wygląda następująco -

2 days 00:00:00

to_timedelta ()

Korzystanie z najwyższego poziomu pd.to_timedelta, możesz przekonwertować wartość skalarną, tablicę, listę lub serię z rozpoznawanego formatu / wartości timedelta na typ Timedelta. Konstruuje Serie, jeśli dane wejściowe są Seriami, skalarnymi, jeśli dane wejściowe są podobne do skalarnych, w przeciwnym razie wyprowadzaTimedeltaIndex.

import pandas as pd

print pd.Timedelta(days=2)

Jego output wygląda następująco -

2 days 00:00:00

Operacje

Możesz operować na Series / DataFrames i konstruować timedelta64[ns] Szeregi przez odejmowanie na datetime64[ns] Seria lub sygnatury czasowe.

Utwórzmy teraz ramkę DataFrame z obiektami Timedelta i datetime i wykonaj na niej pewne operacje arytmetyczne -

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

Jego output wygląda następująco -

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

Operacje dodawania

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

Jego output wygląda następująco -

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

Operacja odejmowania

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

Jego output wygląda następująco -

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

Często w czasie rzeczywistym dane zawierają powtarzalne kolumny tekstowe. Funkcje takie jak płeć, kraj i kody są zawsze powtarzalne. Oto przykłady danych kategorycznych.

Zmienne kategorialne mogą przyjmować tylko ograniczoną i zwykle stałą liczbę możliwych wartości. Oprócz stałej długości dane kategorialne mogą mieć kolejność, ale nie mogą wykonywać operacji numerycznych. Kategoryczne to typ danych Pandy.

Kategoryczny typ danych jest przydatny w następujących przypadkach:

Zmienna łańcuchowa składająca się tylko z kilku różnych wartości. Konwersja takiej zmiennej łańcuchowej na zmienną kategorialną pozwoli zaoszczędzić trochę pamięci.
Porządek leksykalny zmiennej nie jest taki sam, jak porządek logiczny („jeden”, „dwa”, „trzy”). Konwertując na kategorię i określając kolejność kategorii, sortowanie i min / max użyją kolejności logicznej zamiast porządku leksykalnego.
Jako sygnał dla innych bibliotek Pythona, że ta kolumna powinna być traktowana jako zmienna kategorialna (np. Aby zastosować odpowiednie metody statystyczne lub typy wykresów).

Tworzenie obiektów

Obiekt kategoryczny można utworzyć na wiele sposobów. Poniżej opisano różne sposoby -

Kategoria

Określając dtype jako „kategorię” podczas tworzenia obiektów pandy.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print s

Jego output wygląda następująco -

0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

Liczba elementów przekazanych do obiektu serii to cztery, ale kategorie to tylko trzy. Obserwuj to samo w wyjściowych kategoriach.

pd. kategoryczne

Korzystając ze standardowego konstruktora kategorii pandas, możemy utworzyć obiekt kategorii.

pandas.Categorical(values, categories, ordered)

Weźmy przykład -

import pandas as pd

cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print cat

Jego output wygląda następująco -

[a, b, c, a, b, c]
Categories (3, object): [a, b, c]

Spójrzmy na inny przykład -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
print cat

Jego output wygląda następująco -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c, b, a]

Tutaj drugi argument oznacza kategorie. W ten sposób każda wartość, której nie ma w kategoriach, będzie traktowana jakoNaN.

Teraz spójrz na następujący przykład -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
print cat

Jego output wygląda następująco -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c < b < a]

Logicznie rzecz biorąc, zamówienie oznacza, że a jest większy niż b i b jest większy niż c.

Opis

Używając .describe() polecenie na danych kategorycznych, otrzymujemy podobny wynik do pliku Series lub DataFrame z type strunowy.

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()

Jego output wygląda następująco -

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

Pobierz właściwości kategorii

obj.cat.categories polecenie służy do pobierania pliku 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

Jego output wygląda następująco -

Index([u'b', u'a', u'c'], dtype='object')

obj.ordered polecenie służy do uzyskania kolejności obiektu.

import pandas as pd
import numpy as np

cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print cat.ordered

Jego output wygląda następująco -

False

Funkcja zwróciła false ponieważ nie określiliśmy żadnego zamówienia.

Zmiana nazw kategorii

Zmiana nazw kategorii odbywa się poprzez przypisanie nowych wartości do series.cat.categoriesseries.cat.categories.

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

Jego output wygląda następująco -

Index([u'Group a', u'Group b', u'Group c'], dtype='object')

Kategorie początkowe [a,b,c] są aktualizowane przez s.cat.categories własność obiektu.

Dołączanie nowych kategorii

Za pomocą metody Categorical.add.categories () można dołączać nowe kategorie.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
s = s.cat.add_categories([4])
print s.cat.categories

Jego output wygląda następująco -

Index([u'a', u'b', u'c', 4], dtype='object')

Usuwanie kategorii

Używając Categorical.remove_categories() niechciane kategorie mogą zostać usunięte.

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")

Jego output wygląda następująco -

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]

Porównanie danych kategorialnych

Porównanie danych kategorycznych z innymi obiektami jest możliwe w trzech przypadkach -

porównywanie równości (== i! =) z obiektem podobnym do listy (lista, seria, tablica, ...) o tej samej długości co dane jakościowe.
wszystkie porównania (==,! =,>,> =, <i <=) danych kategorialnych z innymi seriami jakościowymi, gdy uporządkowane == Prawda i kategorie są takie same.
wszystkie porównania danych jakościowych ze skalarem.

Spójrz na następujący przykład -

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

Jego output wygląda następująco -

0  False
1  False
2  True
dtype: bool

Podstawowe drukowanie: działka

Ta funkcja w Series i DataFrame to tylko proste opakowanie wokół matplotlib libraries plot() metoda.

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()

Jego output wygląda następująco -

Jeśli indeks składa się z dat, wywołuje gct().autofmt_xdate() aby sformatować oś X, jak pokazano na powyższej ilustracji.

Możemy wykreślić jedną kolumnę z inną za pomocą x i y słowa kluczowe.

Metody drukowania pozwalają na użycie kilku stylów wydruku innych niż domyślny wykres liniowy. Te metody można podać jako argument słowa kluczowego kind dlaplot(). Należą do nich -

bar lub barh dla wykresów słupkowych
hist dla histogramu
pudełko na wykres pudełkowy
„obszar” dla działek powierzchniowych
„scatter” w przypadku wykresów punktowych

Działka barowa

Zobaczmy teraz, czym jest wykres słupkowy, tworząc go. Wykres słupkowy można utworzyć w następujący sposób -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar()

Jego output wygląda następująco -

Aby utworzyć skumulowany wykres słupkowy, 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)

Jego output wygląda następująco -

Aby uzyskać poziome wykresy słupkowe, użyj barh metoda -

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)

Jego output wygląda następująco -

Histogramy

Histogramy można wykreślić za pomocą plot.hist()metoda. Możemy określić liczbę pojemników.

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)

Jego output wygląda następująco -

Aby wykreślić różne histogramy dla każdej kolumny, użyj następującego kodu -

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)

Jego output wygląda następująco -

Wykresy pudełkowe

Boxplot można narysować wywołując Series.box.plot() i DataFrame.box.plot()lub DataFrame.boxplot() wizualizować rozkład wartości w każdej kolumnie.

Na przykład, tutaj jest wykres pudełkowy przedstawiający pięć prób 10 obserwacji jednolitej zmiennej losowej na [0,1).

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()

Jego output wygląda następująco -

Działka powierzchni

Wykres powierzchni można utworzyć za pomocą Series.plot.area() albo DataFrame.plot.area() metody.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])
df.plot.area()

Jego output wygląda następująco -

Wykres punktowy

Wykres punktowy można utworzyć za pomocą DataFrame.plot.scatter() metody.

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')

Jego output wygląda następująco -

Wykres kołowy

Wykres kołowy można utworzyć za pomocą DataFrame.plot.pie() metoda.

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)

Jego output wygląda następująco -

Plik Pandas I/O API to zestaw funkcji czytnika najwyższego poziomu, do których można uzyskać dostęp, np pd.read_csv() które zwykle zwracają obiekt Pandas.

Dwie funkcje konia roboczego do czytania plików tekstowych (lub plików płaskich) to read_csv() i read_table(). Obaj używają tego samego kodu analizującego, aby inteligentnie konwertować dane tabelaryczne na plikDataFrame obiekt -

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

Oto jak csv dane pliku wyglądają następująco -

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

Zapisz te dane jako temp.csv i przeprowadzać na nim operacje.

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

Zapisz te dane jako temp.csv i przeprowadzać na nim operacje.

read.csv

read.csv odczytuje dane z plików csv i tworzy obiekt DataFrame.

import pandas as pd

df=pd.read_csv("temp.csv")
print df

Jego output wygląda następująco -

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

indeks niestandardowy

Określa kolumnę w pliku csv, aby dostosować indeks przy użyciu index_col.

import pandas as pd

df=pd.read_csv("temp.csv",index_col=['S.No'])
print df

Jego output wygląda następująco -

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

Konwertery

dtype kolumn można przekazać jako dykt.

import pandas as pd

df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print df.dtypes

Jego output wygląda następująco -

S.No       int64
Name      object
Age        int64
City      object
Salary   float64
dtype: object

Domyślnie dtype w kolumnie Wynagrodzenie to int, ale wynik pokazuje to jako float ponieważ jawnie wyrzuciliśmy typ.

W związku z tym dane wyglądają jak zmiennoprzecinkowe -

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

nazwy_nagłówków

Określ nazwy nagłówka, używając argumentu nazw.

import pandas as pd
 
df=pd.read_csv("temp.csv", names=['a', 'b', 'c','d','e'])
print df

Jego output wygląda następująco -

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

Zwróć uwagę, że do nazw nagłówków dołączane są nazwy niestandardowe, ale nagłówek w pliku nie został wyeliminowany. Teraz używamy argumentu nagłówka, aby to usunąć.

Jeśli nagłówek znajduje się w wierszu innym niż pierwszy, przekaż numer wiersza do nagłówka. Spowoduje to pominięcie poprzednich wierszy.

import pandas as pd 

df=pd.read_csv("temp.csv",names=['a','b','c','d','e'],header=0)
print df

Jego output wygląda następująco -

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

skiprows

skiprows pomija określoną liczbę wierszy.

import pandas as pd

df=pd.read_csv("temp.csv", skiprows=2)
print df

Jego output wygląda następująco -

2      Lee   32    HongKong   3000
0   3   Steven   43    Bay Area   8300
1   4      Ram   38   Hyderabad   3900

Rzadkie obiekty są „kompresowane”, gdy pomijane są jakiekolwiek dane pasujące do określonej wartości (NaN / brakująca wartość, chociaż można wybrać dowolną wartość). Specjalny obiekt SparseIndex śledzi, gdzie dane zostały „rozproszone”. Na przykładzie będzie to o wiele bardziej sensowne. Wszystkie standardowe struktury danych Pandas stosują rozszerzenieto_sparse metoda -

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

Jego output wygląda następująco -

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)

Rzadkie obiekty istnieją ze względu na wydajność pamięci.

Załóżmy teraz, że masz dużą ramkę DataFrame NA i wykonaj następujący kod -

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

Jego output wygląda następująco -

0.0001

Każdy rzadki obiekt można przekształcić z powrotem w standardową gęstą formę przez wywołanie 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()

Jego output wygląda następująco -

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

Rzadkie Dtypes

Rzadkie dane powinny mieć ten sam typ dty, co ich gęsta reprezentacja. W tej chwili,float64, int64 i booldtypessą obsługiwane. W zależności od oryginałudtype, fill_value default zmiany -

float64 - np.nan
int64 - 0
bool - Fałsz

Wykonajmy następujący kod, aby zrozumieć to samo -

import pandas as pd
import numpy as np

s = pd.Series([1, np.nan, np.nan])
print s

s.to_sparse()
print s

Jego output wygląda następująco -

0   1.0
1   NaN
2   NaN
dtype: float64

0   1.0
1   NaN
2   NaN
dtype: float64

Ostrzeżenia oznaczają ostrzeżenie, a gotcha oznacza niewidoczny problem.

Używanie stwierdzenia If / Truth z Pandami

Pandy przestrzegają konwencji numpy polegającej na zgłaszaniu błędu, gdy próbujesz przekonwertować coś na plik bool. Dzieje się to wif lub when używając operacji logicznych, oraz orlub not. Nie jest jasne, jaki powinien być wynik. Czy powinno być prawdziwe, ponieważ nie ma długości zerowej? Fałsz, ponieważ istnieją wartości Fałsz? Nie jest jasne, więc zamiast tego Pandy podnosiValueError -

import pandas as pd

if pd.Series([False, True, False]):
   print 'I am True'

Jego output wygląda następująco -

ValueError: The truth value of a Series is ambiguous. 
Use a.empty, a.bool() a.item(),a.any() or a.all().

W ifwarunku, nie jest jasne, co z tym zrobić. Błąd sugeruje, czy użyć plikuNone lub any of those.

import pandas as pd

if pd.Series([False, True, False]).any():
   print("I am any")

Jego output wygląda następująco -

I am any

Aby ocenić jednoelementowe obiekty pandy w kontekście logicznym, użyj metody .bool() -

import pandas as pd

print pd.Series([True]).bool()

Jego output wygląda następująco -

True

Bitwise Boolean

Bitowe operatory logiczne, takie jak == i != zwróci szereg boolowski, który i tak jest prawie zawsze wymagany.

import pandas as pd

s = pd.Series(range(5))
print s==4

Jego output wygląda następująco -

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

operacja isin

Zwraca serię logiczną pokazującą, czy każdy element w serii jest dokładnie zawarty w przekazanej sekwencji wartości.

import pandas as pd

s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print s

Jego output wygląda następująco -

0 True
1 False
2 True
dtype: bool

Reindeksowanie vs ix Gotcha

Wielu użytkowników będzie używać rozszerzenia ix indexing capabilities jako zwięzły sposób wyboru danych z obiektu Pandas -

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']]

Jego output wygląda następująco -

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

Jest to oczywiście całkowicie równoważne w tym przypadku z użyciem reindex metoda -

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'])

Jego output wygląda następująco -

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

Niektórzy mogą to stwierdzić ix i reindexsą w 100% równoważne na tej podstawie. Dzieje się tak z wyjątkiem indeksowania liczb całkowitych. Na przykład powyższą operację można alternatywnie wyrazić jako -

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])

Jego output wygląda następująco -

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

Należy o tym pamiętać reindex is strict label indexing only. Może to prowadzić do potencjalnie zaskakujących wyników w przypadkach patologicznych, w których indeks zawiera, powiedzmy, zarówno liczby całkowite, jak i łańcuchy.

Ponieważ wielu potencjalnych użytkowników Pand jest zaznajomionych z SQL, ta strona ma na celu przedstawienie przykładów tego, jak różne operacje SQL mogą być wykonywane przy użyciu pand.

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()

Jego output wygląda następująco -

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

WYBIERZ

W SQL selekcji dokonuje się za pomocą listy kolumn oddzielonych przecinkami, które wybierasz (lub *, aby zaznaczyć wszystkie kolumny) -

SELECT total_bill, tip, smoker, time
FROM tips
LIMIT 5;

W przypadku Pandas wybór kolumn odbywa się poprzez przekazanie listy nazw kolumn do ramki DataFrame -

tips[['total_bill', 'tip', 'smoker', 'time']].head(5)

Sprawdźmy cały program -

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)

Jego output wygląda następująco -

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

Wywołanie DataFrame bez listy nazw kolumn spowoduje wyświetlenie wszystkich kolumn (podobnie jak SQL *).

GDZIE

Filtrowanie w języku SQL odbywa się za pomocą klauzuli WHERE.

SELECT * FROM tips WHERE time = 'Dinner' LIMIT 5;

Ramki danych można filtrować na wiele sposobów; najbardziej intuicyjny z nich to indeksowanie boolowskie.

tips[tips['time'] == 'Dinner'].head(5)

Sprawdźmy cały program -

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)

Jego output wygląda następująco -

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

Powyższa instrukcja przekazuje serię obiektów True / False do DataFrame, zwracając wszystkie wiersze z wartością True.

Grupuj według

Ta operacja pobiera liczbę rekordów w każdej grupie w całym zestawie danych. Na przykład zapytanie pobierające liczbę wskazówek pozostawionych przez płeć -

SELECT sex, count(*)
FROM tips
GROUP BY sex;

Odpowiednik Pand byłby -

tips.groupby('sex').size()

Sprawdźmy cały program -

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()

Jego output wygląda następująco -

sex
Female   87
Male    157
dtype: int64

N rzędów górnych

SQL zwraca top n rows za pomocą LIMIT -

SELECT * FROM tips
LIMIT 5 ;

Odpowiednik Pand byłby -

tips.head(5)

Sprawdźmy pełny przykład -

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

Jego output wygląda następująco -

smoker   day     time
0      No   Sun   Dinner
1      No   Sun   Dinner
2      No   Sun   Dinner
3      No   Sun   Dinner
4      No   Sun   Dinner

Oto kilka podstawowych operacji, które porównaliśmy, o których dowiedzieliśmy się w poprzednich rozdziałach Biblioteki Pandas.