Python Pandas - Kurzanleitung

Pandas ist eine Open-Source-Python-Bibliothek, die mithilfe ihrer leistungsstarken Datenstrukturen ein leistungsstarkes Tool zur Datenmanipulation und -analyse bietet. Der Name Pandas leitet sich vom Wort Panel Data ab - eine Ökonometrie aus mehrdimensionalen Daten.

Im Jahr 2008 begann Entwickler Wes McKinney mit der Entwicklung von Pandas, wenn ein leistungsstarkes, flexibles Tool zur Datenanalyse benötigt wurde.

Vor Pandas wurde Python hauptsächlich zum Munging und zur Vorbereitung von Daten verwendet. Es hatte sehr wenig Beitrag zur Datenanalyse. Pandas haben dieses Problem gelöst. Mit Pandas können wir fünf typische Schritte bei der Verarbeitung und Analyse von Daten ausführen, unabhängig von der Herkunft der Daten - Laden, Vorbereiten, Bearbeiten, Modellieren und Analysieren.

Python mit Pandas wird in einer Vielzahl von Bereichen eingesetzt, einschließlich akademischer und kommerzieller Bereiche wie Finanzen, Wirtschaft, Statistik, Analytik usw.

Hauptmerkmale von Pandas

Schnelles und effizientes DataFrame-Objekt mit standardmäßiger und angepasster Indizierung.
Tools zum Laden von Daten in speicherinterne Datenobjekte aus verschiedenen Dateiformaten.
Datenausrichtung und integrierter Umgang mit fehlenden Daten.
Umformen und Schwenken von Datumssätzen.
Label-basiertes Slicing, Indizieren und Subsetting großer Datenmengen.
Spalten aus einer Datenstruktur können gelöscht oder eingefügt werden.
Gruppieren nach Daten für Aggregation und Transformationen.
Hochleistungs-Zusammenführen und Zusammenführen von Daten.
Zeitreihenfunktionalität.

Die Standard-Python-Distribution wird nicht mit dem Pandas-Modul geliefert. Eine einfache Alternative ist die Installation von NumPy mit dem beliebten Python-Paketinstallationsprogramm.pip.

pip install pandas

Wenn Sie das Anaconda Python-Paket installieren, wird Pandas standardmäßig wie folgt installiert:

Windows

Anaconda (von https://www.continuum.io) ist eine kostenlose Python-Distribution für den SciPy-Stack. Es ist auch für Linux und Mac verfügbar.
Canopy (https://www.enthought.com/products/canopy/) ist sowohl als kostenlose als auch als kommerzielle Distribution mit vollem SciPy-Stack für Windows, Linux und Mac erhältlich.
Python(x, y) ist eine kostenlose Python-Distribution mit SciPy-Stack und Spyder IDE für Windows. (Herunterladbar vonhttp://python-xy.github.io/)

Linux

Paketmanager der jeweiligen Linux-Distributionen werden verwendet, um ein oder mehrere Pakete im SciPy-Stack zu installieren.

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 befasst sich mit den folgenden drei Datenstrukturen:

Series
DataFrame
Panel

Diese Datenstrukturen bauen auf dem Numpy-Array auf, was bedeutet, dass sie schnell sind.

Dimension & Beschreibung

Der beste Weg, sich diese Datenstrukturen vorzustellen, besteht darin, dass die höherdimensionale Datenstruktur ein Container ihrer niedrigdimensionalen Datenstruktur ist. Beispielsweise ist DataFrame ein Container der Serie, Panel ist ein Container der DataFrame.

Datenstruktur	Maße	Beschreibung
Serie	1	1D markiertes homogenes Array, größenveränderbar.
Datenrahmen	2	Allgemeine 2D-markierte, größenveränderliche tabellarische Struktur mit möglicherweise heterogen typisierten Spalten.
Panel	3	Allgemeines 3D-markiertes, größenveränderliches Array.

Das Erstellen und Behandeln von zwei oder mehr dimensionalen Arrays ist eine mühsame Aufgabe. Der Benutzer muss beim Schreiben von Funktionen die Ausrichtung des Datensatzes berücksichtigen. Durch die Verwendung von Pandas-Datenstrukturen wird jedoch die mentale Anstrengung des Benutzers reduziert.

Bei tabellarischen Daten (DataFrame) ist es beispielsweise semantisch hilfreicher, an die zu denken index (die Reihen) und die columns anstatt Achse 0 und Achse 1.

Wandlungsfähigkeit

Alle Pandas-Datenstrukturen sind wertveränderlich (können geändert werden) und mit Ausnahme von Serien sind alle größenveränderlich. Serie ist Größe unveränderlich.

Note- DataFrame ist weit verbreitet und eine der wichtigsten Datenstrukturen. Panel wird viel weniger verwendet.

Serie

Serie ist eine eindimensionale Array-ähnliche Struktur mit homogenen Daten. Die folgende Reihe ist beispielsweise eine Sammlung von ganzen Zahlen 10, 23, 56,…

10	23	56	17	52	61	73	90	26	72

Wichtige Punkte

Homogene Daten
Größe unveränderlich
Werte von Daten veränderlich

DataFrame

DataFrame ist ein zweidimensionales Array mit heterogenen Daten. Zum Beispiel,

Name	Alter	Geschlecht	Bewertung
Steve	32	Männlich	3.45
Lia	28	Weiblich	4.6
Vin	45	Männlich	3.9
Katie	38	Weiblich	2,78

Die Tabelle enthält die Daten eines Verkaufsteams einer Organisation mit ihrer Gesamtleistungsbewertung. Die Daten werden in Zeilen und Spalten dargestellt. Jede Spalte repräsentiert ein Attribut und jede Zeile repräsentiert eine Person.

Datentyp der Spalten

Die Datentypen der vier Spalten sind wie folgt:

Säule	Art
Name	String
Alter	Ganze Zahl
Geschlecht	String
Bewertung	Schweben

Wichtige Punkte

Heterogene Daten
Größe veränderlich
Daten veränderlich

Panel

Panel ist eine dreidimensionale Datenstruktur mit heterogenen Daten. Es ist schwierig, das Panel in grafischer Darstellung darzustellen. Ein Panel kann jedoch als Container von DataFrame dargestellt werden.

Wichtige Punkte

Heterogene Daten
Größe veränderlich
Daten veränderlich

Series ist ein eindimensional beschriftetes Array, das Daten aller Art (Integer-, String-, Float-, Python-Objekte usw.) aufnehmen kann. Die Achsenbeschriftungen werden zusammen als Index bezeichnet.

pandas.Series

Eine Pandas-Serie kann mit dem folgenden Konstruktor erstellt werden:

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

Die Parameter des Konstruktors sind wie folgt:

Sr.Nr.	Parameter & Beschreibung
1	data Daten haben verschiedene Formen wie ndarray, list, constants
2	index Indexwerte müssen eindeutig und hashbar sein und dieselbe Länge wie Daten haben. Standardnp.arange(n) wenn kein Index übergeben wird.
3	dtype dtype ist für den Datentyp. Wenn Keine, wird der Datentyp abgeleitet
4	copy Daten kopieren. Standard False

Eine Serie kann mit verschiedenen Eingaben wie - erstellt werden

Array
Dict
Skalarwert oder Konstante

Erstellen Sie eine leere Serie

Eine Basisserie, die erstellt werden kann, ist eine leere Serie.

Beispiel

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

Es ist output ist wie folgt -

Series([], dtype: float64)

Erstellen Sie eine Serie aus ndarray

Wenn es sich bei den Daten um ein ndarray handelt, muss der übergebene Index dieselbe Länge haben. Wenn kein Index übergeben wird, ist dies standardmäßig der Indexrange(n) wo n ist die Array-Länge, dh [0,1,2,3…. range(len(array))-1].

Beispiel 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

Es ist output ist wie folgt -

0   a
1   b
2   c
3   d
dtype: object

Wir haben keinen Index übergeben, daher wurden standardmäßig die Indizes von 0 bis zugewiesen len(data)-1dh 0 bis 3.

Beispiel 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

Es ist output ist wie folgt -

100  a
101  b
102  c
103  d
dtype: object

Wir haben hier die Indexwerte übergeben. Jetzt können wir die benutzerdefinierten indizierten Werte in der Ausgabe sehen.

Erstellen Sie eine Serie aus dict

EIN dictkann als Eingabe übergeben werden. Wenn kein Index angegeben ist, werden die Wörterbuchschlüssel in einer sortierten Reihenfolge verwendet, um einen Index zu erstellen. Wennindex übergeben wird, werden die Werte in Daten, die den Beschriftungen im Index entsprechen, herausgezogen.

Beispiel 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

Es ist output ist wie folgt -

a 0.0
b 1.0
c 2.0
dtype: float64

Observe - Wörterbuchschlüssel werden zum Erstellen eines Index verwendet.

Beispiel 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

Es ist output ist wie folgt -

b 1.0
c 2.0
d NaN
a 0.0
dtype: float64

Observe - Die Indexreihenfolge bleibt bestehen und das fehlende Element wird mit NaN (Not a Number) gefüllt.

Erstellen Sie eine Serie aus Scalar

Wenn Daten ein Skalarwert sind, muss ein Index angegeben werden. Der Wert wird wiederholt, um der Länge von zu entsprechenindex

#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

Es ist output ist wie folgt -

0  5
1  5
2  5
3  5
dtype: int64

Zugriff auf Daten aus Serien mit Position

Auf Daten in der Reihe kann ähnlich wie in einem zugegriffen werden ndarray.

Beispiel 1

Rufen Sie das erste Element ab. Wie wir bereits wissen, beginnt die Zählung für das Array bei Null, was bedeutet, dass das erste Element an der ^nullten Position gespeichert wird und so weiter.

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]

Es ist output ist wie folgt -

Beispiel 2

Rufen Sie die ersten drei Elemente der Serie ab. Wenn ein: davor eingefügt wird, werden alle Elemente ab diesem Index extrahiert. Wenn zwei Parameter (mit: zwischen ihnen) verwendet werden, werden Elemente zwischen den beiden Indizes (ohne den Stoppindex) verwendet.

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]

Es ist output ist wie folgt -

a  1
b  2
c  3
dtype: int64

Beispiel 3

Rufen Sie die letzten drei Elemente ab.

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

Es ist output ist wie folgt -

c  3
d  4
e  5
dtype: int64

Daten mit Label (Index) abrufen

Eine Serie ist wie eine feste Größe dict , dass Sie Werte über die Indexbezeichnung abrufen und festlegen können.

Beispiel 1

Rufen Sie ein einzelnes Element mit dem Indexbezeichnungswert ab.

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

Es ist output ist wie folgt -

Beispiel 2

Rufen Sie mehrere Elemente mithilfe einer Liste von Indexbeschriftungswerten ab.

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

Es ist output ist wie folgt -

a  1
c  3
d  4
dtype: int64

Beispiel 3

Wenn kein Label enthalten ist, wird eine Ausnahme ausgelöst.

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

#retrieve multiple elements
print s['f']

Es ist output ist wie folgt -

…
KeyError: 'f'

Ein Datenrahmen ist eine zweidimensionale Datenstruktur, dh Daten werden in Zeilen und Spalten tabellarisch ausgerichtet.

Funktionen von DataFrame

Potenziell sind Spalten unterschiedlicher Art
Größe - veränderlich
Beschriftete Achsen (Zeilen und Spalten)
Kann arithmetische Operationen für Zeilen und Spalten ausführen

Struktur

Nehmen wir an, wir erstellen einen Datenrahmen mit den Daten des Schülers.

Sie können sich das als SQL-Tabelle oder als Darstellung von Tabellenkalkulationsdaten vorstellen.

pandas.DataFrame

Ein Pandas DataFrame kann mit dem folgenden Konstruktor erstellt werden:

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

Die Parameter des Konstruktors sind wie folgt:

Sr.Nr.	Parameter & Beschreibung
1	data Daten haben verschiedene Formen wie ndarray, Serien, Karten, Listen, Diktate, Konstanten und auch einen anderen DataFrame.
2	index Für die Zeilenbeschriftungen lautet der Index, der für den resultierenden Frame verwendet werden soll, Optional Standard np.arange (n), wenn kein Index übergeben wird.
3	columns Für Spaltenbeschriftungen lautet die optionale Standardsyntax - np.arange (n). Dies gilt nur, wenn kein Index übergeben wird.
4	dtype Datentyp jeder Spalte.
5	copy Dieser Befehl (oder was auch immer) wird zum Kopieren von Daten verwendet, wenn der Standardwert False ist.

Erstellen Sie einen DataFrame

Ein Pandas DataFrame kann mit verschiedenen Eingaben wie - erstellt werden

Lists
dict
Series
Numpy ndarrays
Ein weiterer DataFrame

In den folgenden Abschnitten dieses Kapitels erfahren Sie, wie Sie mit diesen Eingaben einen DataFrame erstellen.

Erstellen Sie einen leeren Datenrahmen

Ein grundlegender DataFrame, der erstellt werden kann, ist ein leerer Dataframe.

Beispiel

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

Es ist output ist wie folgt -

Empty DataFrame
Columns: []
Index: []

Erstellen Sie einen DataFrame aus Listen

Der DataFrame kann mithilfe einer einzelnen Liste oder einer Liste von Listen erstellt werden.

Beispiel 1

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

Es ist output ist wie folgt -

Beispiel 2

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

Es ist output ist wie folgt -

Name      Age
0     Alex      10
1     Bob       12
2     Clarke    13

Beispiel 3

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

Es ist output ist wie folgt -

Name     Age
0     Alex     10.0
1     Bob      12.0
2     Clarke   13.0

Note - Beobachten Sie, die dtype Der Parameter ändert den Typ der Altersspalte in Gleitkomma.

Erstellen Sie einen DataFrame aus Dict of ndarrays / Lists

All die ndarraysmuss gleich lang sein. Wenn der Index übergeben wird, sollte die Länge des Index der Länge der Arrays entsprechen.

Wenn kein Index übergeben wird, ist der Index standardmäßig der Bereich (n), wobei n ist die Array-Länge.

Beispiel 1

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

Es ist output ist wie folgt -

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

Note- Beachten Sie die Werte 0,1,2,3. Sie sind der Standardindex, der jedem anhand des Funktionsbereichs (n) zugewiesen wird.

Beispiel 2

Lassen Sie uns nun einen indizierten DataFrame mithilfe von Arrays erstellen.

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

Es ist output ist wie folgt -

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

Note - Beobachten Sie, die index Der Parameter weist jeder Zeile einen Index zu.

Erstellen Sie einen DataFrame aus der Liste der Dicts

Eine Liste von Wörterbüchern kann als Eingabedaten übergeben werden, um einen DataFrame zu erstellen. Die Wörterbuchschlüssel werden standardmäßig als Spaltennamen verwendet.

Beispiel 1

Das folgende Beispiel zeigt, wie Sie einen DataFrame erstellen, indem Sie eine Liste von Wörterbüchern übergeben.

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

Es ist output ist wie folgt -

a    b      c
0   1   2     NaN
1   5   10   20.0

Note - Beachten Sie, dass NaN (Not a Number) in fehlenden Bereichen angehängt wird.

Beispiel 2

Das folgende Beispiel zeigt, wie Sie einen DataFrame erstellen, indem Sie eine Liste der Wörterbücher und der Zeilenindizes übergeben.

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

Es ist output ist wie folgt -

a   b       c
first   1   2     NaN
second  5   10   20.0

Beispiel 3

Das folgende Beispiel zeigt, wie Sie einen DataFrame mit einer Liste von Wörterbüchern, Zeilenindizes und Spaltenindizes erstellen.

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

Es ist output ist wie folgt -

#df1 output
         a  b
first    1  2
second   5  10

#df2 output
         a  b1
first    1  NaN
second   5  NaN

Note- Beachten Sie, dass df2 DataFrame mit einem anderen Spaltenindex als dem Wörterbuchschlüssel erstellt wird. Daher wurden die NaNs an Ort und Stelle angehängt. Während df1 mit Spaltenindizes wie Wörterbuchschlüssel erstellt wird, wird NaN angehängt.

Erstellen Sie einen DataFrame aus Dict of Series

Das Wörterbuch der Serien kann als DataFrame übergeben werden. Der resultierende Index ist die Vereinigung aller übergebenen Serienindizes.

Beispiel

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

Es ist output ist wie folgt -

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

Note - Beachten Sie, dass es für die erste Serie kein Etikett gibt ‘d’ bestanden, aber im Ergebnis für die d Etikett, NaN wird mit NaN angehängt.

Lass uns jetzt verstehen column selection, addition, und deletion durch Beispiele.

Spaltenauswahl

Wir werden dies verstehen, indem wir eine Spalte aus dem DataFrame auswählen.

Beispiel

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

Es ist output ist wie folgt -

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

Spaltenaddition

Wir werden dies verstehen, indem wir einem vorhandenen Datenrahmen eine neue Spalte hinzufügen.

Beispiel

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

Es ist output ist wie folgt -

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

Spalten löschen

Spalten können gelöscht oder gelöscht werden. Nehmen wir ein Beispiel, um zu verstehen, wie.

Beispiel

# 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

Es ist output ist wie folgt -

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

Zeilenauswahl, Hinzufügung und Löschung

Wir werden nun das Auswählen, Hinzufügen und Löschen von Zeilen anhand von Beispielen verstehen. Beginnen wir mit dem Konzept der Auswahl.

Auswahl nach Label

Zeilen können ausgewählt werden, indem die Zeilenbezeichnung an a übergeben wird loc Funktion.

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

Es ist output ist wie folgt -

one 2.0
two 2.0
Name: b, dtype: float64

Das Ergebnis ist eine Reihe mit Beschriftungen als Spaltennamen des DataFrame. Und der Name der Serie ist das Etikett, mit dem sie abgerufen wird.

Auswahl nach ganzzahliger Position

Zeilen können ausgewählt werden, indem eine ganzzahlige Position an eine übergeben wird iloc Funktion.

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]

Es ist output ist wie folgt -

one   3.0
two   3.0
Name: c, dtype: float64

Reihen schneiden

Mit dem Operator ':' können mehrere Zeilen ausgewählt werden.

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]

Es ist output ist wie folgt -

one  two
c  3.0    3
d  NaN    4

Hinzufügen von Zeilen

Fügen Sie einem DataFrame mithilfe von neue Zeilen hinzu appendFunktion. Diese Funktion hängt die Zeilen am Ende an.

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

Es ist output ist wie folgt -

Löschen von Zeilen

Verwenden Sie die Indexbezeichnung, um Zeilen aus einem DataFrame zu löschen oder zu löschen. Wenn die Beschriftung dupliziert wird, werden mehrere Zeilen gelöscht.

Wenn Sie im obigen Beispiel beobachten, sind die Beschriftungen doppelt vorhanden. Lassen Sie uns ein Etikett ablegen und sehen, wie viele Zeilen gelöscht werden.

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

Es ist output ist wie folgt -

a b
1 3 4
1 7 8

Im obigen Beispiel wurden zwei Zeilen gelöscht, da diese beiden die gleiche Bezeichnung 0 enthalten.

EIN panelist ein 3D-Datencontainer. Der BegriffPanel data ist aus der Ökonometrie abgeleitet und teilweise verantwortlich für den Namen Pandas - pan(el)-da(ta)-s.

Die Namen für die 3 Achsen sollen der Beschreibung von Operationen mit Paneldaten eine semantische Bedeutung verleihen. Sie sind -

items - Achse 0, jedes Element entspricht einem darin enthaltenen DataFrame.
major_axis - Achse 1, es ist der Index (Zeilen) jedes der DataFrames.
minor_axis - Achse 2, es sind die Spalten jedes der DataFrames.

pandas.Panel ()

Ein Panel kann mit dem folgenden Konstruktor erstellt werden:

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

Die Parameter des Konstruktors sind wie folgt:

Parameter	Beschreibung
Daten	Daten haben verschiedene Formen wie ndarray, Serien, Karten, Listen, Diktate, Konstanten und auch einen anderen DataFrame
Artikel	Achse = 0
Hauptachse	Achse = 1
minor_axis	Achse = 2
dtype	Datentyp jeder Spalte
Kopieren	Daten kopieren. Standard,false

Panel erstellen

Ein Panel kann auf verschiedene Arten erstellt werden:

Von ndarrays
Aus dem Diktat von DataFrames

Aus 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

Es ist output ist wie folgt -

<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 - Beachten Sie die Abmessungen des leeren Feldes und des obigen Feldes, alle Objekte sind unterschiedlich.

Aus dem Diktat von DataFrame-Objekten

#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

Es ist output ist wie folgt -

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

Erstellen Sie ein leeres Bedienfeld

Ein leeres Panel kann mit dem Panel-Konstruktor wie folgt erstellt werden:

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

Es ist output ist wie folgt -

<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

Auswählen der Daten aus dem Bedienfeld

Wählen Sie die Daten aus dem Bedienfeld mit - aus

Items
Major_axis
Minor_axis

Elemente verwenden

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

Es ist output ist wie folgt -

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

Wir haben zwei Elemente und haben Element1 abgerufen. Das Ergebnis ist ein DataFrame mit 4 Zeilen und 3 SpaltenMajor_axis und Minor_axis Maße.

Verwenden von major_axis

Auf Daten kann mit der Methode zugegriffen werden 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)

Es ist output ist wie folgt -

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

Minor_axis verwenden

Auf Daten kann mit der Methode zugegriffen werden 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)

Es ist output ist wie folgt -

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

Note - Beachten Sie die Änderungen in den Abmessungen.

Inzwischen haben wir die drei Pandas DataStructures kennengelernt und erfahren, wie sie erstellt werden. Wir werden uns aufgrund seiner Bedeutung für die Echtzeit-Datenverarbeitung hauptsächlich auf die DataFrame-Objekte konzentrieren und auch einige andere DataStructures diskutieren.

Grundlegende Funktionalität der Serie

Sr.Nr.	Attribut oder Methode & Beschreibung
1	axes Gibt eine Liste der Zeilenachsenbeschriftungen zurück
2	dtype Gibt den dtype des Objekts zurück.
3	empty Gibt True zurück, wenn die Serie leer ist.
4	ndim Gibt die Anzahl der Dimensionen der zugrunde liegenden Daten per Definition 1 zurück.
5	size Gibt die Anzahl der Elemente in den zugrunde liegenden Daten zurück.
6	values Gibt die Serie als ndarray zurück.
7	head() Gibt die ersten n Zeilen zurück.
8	tail() Gibt die letzten n Zeilen zurück.

Lassen Sie uns nun eine Serie erstellen und alle oben aufgeführten Operationen für tabellarische Attribute anzeigen.

Beispiel

import pandas as pd
import numpy as np

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

Es ist output ist wie folgt -

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

Achsen

Gibt die Liste der Beschriftungen der Serie zurück.

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

Es ist output ist wie folgt -

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

Das obige Ergebnis ist ein kompaktes Format einer Liste von Werten von 0 bis 5, dh [0,1,2,3,4].

leer

Gibt den Booleschen Wert zurück, der angibt, ob das Objekt leer ist oder nicht. True gibt an, dass das Objekt leer ist.

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

Es ist output ist wie folgt -

Is the Object empty?
False

ndim

Gibt die Anzahl der Dimensionen des Objekts zurück. Per Definition ist eine Serie eine 1D-Datenstruktur, daher wird sie zurückgegeben

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

Es ist output ist wie folgt -

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

The dimensions of the object:
1

Größe

Gibt die Größe (Länge) der Serie zurück.

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

Es ist output ist wie folgt -

0   3.078058
1  -1.207803
dtype: float64

The size of the object:
2

Werte

Gibt die tatsächlichen Daten in der Reihe als Array zurück.

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

Es ist output ist wie folgt -

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 ]

Kopf & Schwanz

Verwenden Sie die Methoden head () und tail (), um ein kleines Beispiel einer Serie oder des DataFrame-Objekts anzuzeigen.

head() gibt den ersten zurück nZeilen (Indexwerte beachten). Die Standardanzahl der anzuzeigenden Elemente beträgt fünf, Sie können jedoch eine benutzerdefinierte Anzahl übergeben.

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)

Es ist output ist wie folgt -

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() gibt den letzten zurück nZeilen (Indexwerte beachten). Die Standardanzahl der anzuzeigenden Elemente beträgt fünf, Sie können jedoch eine benutzerdefinierte Anzahl übergeben.

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)

Es ist output ist wie folgt -

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

Grundlegende DataFrame-Funktionalität

Lassen Sie uns nun verstehen, was DataFrame Basic Functionality ist. In den folgenden Tabellen sind die wichtigen Attribute oder Methoden aufgeführt, die für die grundlegende Funktionalität von DataFrame hilfreich sind.

Sr.Nr.	Attribut oder Methode & Beschreibung
1	T Transponiert Zeilen und Spalten.
2	axes Gibt eine Liste mit den Zeilenachsen- und Spaltenachsenbeschriftungen als einzigen Elementen zurück.
3	dtypes Gibt die dtypes in diesem Objekt zurück.
4	empty True, wenn NDFrame vollständig leer ist [keine Elemente]; wenn eine der Achsen die Länge 0 hat.
5	ndim Anzahl der Achsen / Array-Dimensionen.
6	shape Gibt ein Tupel zurück, das die Dimensionalität des DataFrame darstellt.
7	size Anzahl der Elemente im NDFrame.
8	values Numpy Darstellung von NDFrame.
9	head() Gibt die ersten n Zeilen zurück.
10	tail() Gibt die letzten n Zeilen zurück.

Lassen Sie uns nun einen DataFrame erstellen und sehen, wie die oben genannten Attribute funktionieren.

Beispiel

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

Es ist output ist wie folgt -

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

Gibt die Transponierung des DataFrame zurück. Die Zeilen und Spalten werden ausgetauscht.

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

Es ist output ist wie folgt -

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

Achsen

Gibt die Liste der Zeilenachsenbeschriftungen und Spaltenachsenbeschriftungen zurück.

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

Es ist output ist wie folgt -

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

Gibt den Datentyp jeder Spalte zurück.

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

Es ist output ist wie folgt -

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

leer

Gibt den Booleschen Wert zurück, der angibt, ob das Objekt leer ist oder nicht. True gibt an, dass das Objekt leer ist.

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

Es ist output ist wie folgt -

Is the object empty?
False

ndim

Gibt die Anzahl der Dimensionen des Objekts zurück. Per Definition ist DataFrame ein 2D-Objekt.

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

Es ist output ist wie folgt -

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

gestalten

Gibt ein Tupel zurück, das die Dimensionalität des DataFrame darstellt. Tupel (a, b), wobei a die Anzahl der Zeilen und darstelltb repräsentiert die Anzahl der Spalten.

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

Es ist output ist wie folgt -

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)

Größe

Gibt die Anzahl der Elemente im DataFrame zurück.

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

Es ist output ist wie folgt -

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

Werte

Gibt die tatsächlichen Daten im DataFrame als zurück 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

Es ist output ist wie folgt -

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

Kopf & Schwanz

Verwenden Sie die Taste, um ein kleines Beispiel eines DataFrame-Objekts anzuzeigen head() und tail () Methoden. head() gibt den ersten zurück nZeilen (Indexwerte beachten). Die Standardanzahl der anzuzeigenden Elemente beträgt fünf, Sie können jedoch eine benutzerdefinierte Anzahl übergeben.

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)

Es ist output ist wie folgt -

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() gibt den letzten zurück nZeilen (Indexwerte beachten). Die Standardanzahl der anzuzeigenden Elemente beträgt fünf, Sie können jedoch eine benutzerdefinierte Anzahl übergeben.

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)

Es ist output ist wie folgt -

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

Eine große Anzahl von Methoden berechnet gemeinsam beschreibende Statistiken und andere verwandte Operationen in DataFrame. Die meisten davon sind Aggregationen wiesum(), mean(), aber einige von ihnen mögen sumsum(), produzieren ein Objekt der gleichen Größe. Im Allgemeinen nehmen diese Methoden eineaxisArgument, genau wie ndarray. {sum, std, ...}, aber die Achse kann durch Name oder Ganzzahl angegeben werden

DataFrame - "Index" (Achse = 0, Standard), "Spalten" (Achse = 1)

Lassen Sie uns einen DataFrame erstellen und dieses Objekt in diesem Kapitel für alle Operationen verwenden.

Beispiel

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

Es ist output ist wie folgt -

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

Summe()

Gibt die Summe der Werte für die angeforderte Achse zurück. Standardmäßig ist die Achse der Index (Achse = 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()

Es ist output ist wie folgt -

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

Jede einzelne Spalte wird einzeln hinzugefügt (Zeichenfolgen werden angehängt).

Achse = 1

Diese Syntax gibt die Ausgabe wie unten gezeigt aus.

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)

Es ist output ist wie folgt -

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

bedeuten()

Gibt den Durchschnittswert zurück

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

Es ist output ist wie folgt -

Age       31.833333
Rating     3.743333
dtype: float64

std ()

Gibt die Bressel-Standardabweichung der numerischen Spalten zurück.

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

Es ist output ist wie folgt -

Age       9.232682
Rating    0.661628
dtype: float64

Funktionen & Beschreibung

Lassen Sie uns nun die Funktionen unter Beschreibende Statistik in Python Pandas verstehen. In der folgenden Tabelle sind die wichtigen Funktionen aufgeführt -

Sr.Nr.	Funktion	Beschreibung
1	Anzahl()	Anzahl der Nicht-Null-Beobachtungen
2	Summe()	Summe der Werte
3	bedeuten()	Mittelwert der Werte
4	Median()	Median der Werte
5	Modus()	Art der Werte
6	std ()	Standardabweichung der Werte
7	Mindest()	Mindestwert
8	max ()	Höchster Wert
9	Abs()	Absoluter Wert
10	prod ()	Produkt der Werte
11	cumsum ()	Kumulative Summe
12	cumprod ()	Kumulatives Produkt

Note- Da DataFrame eine heterogene Datenstruktur ist. Generische Operationen funktionieren nicht mit allen Funktionen.

Funktionen wie sum(), cumsum()Arbeiten Sie fehlerfrei mit numerischen und Zeichen- (oder) Zeichenfolgendatenelementen. Obwohln In der Praxis werden Zeichenaggregationen im Allgemeinen nie verwendet. Diese Funktionen lösen keine Ausnahme aus.
Funktionen wie abs(), cumprod() Ausnahme auslösen, wenn der DataFrame Zeichen- oder Zeichenfolgendaten enthält, da solche Operationen nicht ausgeführt werden können.

Daten zusammenfassen

Das describe() Die Funktion berechnet eine Zusammenfassung der Statistiken zu den DataFrame-Spalten.

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

Es ist output ist wie folgt -

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

Diese Funktion gibt die mean, std und IQRWerte. Die Funktion schließt die Zeichenspalten und die Zusammenfassung der numerischen Spalten aus.'include'ist das Argument, mit dem die erforderlichen Informationen darüber übergeben werden, welche Spalten für die Zusammenfassung berücksichtigt werden müssen. Nimmt die Liste der Werte; Standardmäßig 'Nummer'.

object - Fasst String-Spalten zusammen
number - Fasst numerische Spalten zusammen
all - Fasst alle Spalten zusammen (sollte nicht als Listenwert übergeben werden)

Verwenden Sie nun die folgende Anweisung im Programm und überprüfen Sie die Ausgabe -

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

Es ist output ist wie folgt -

Name
count       12
unique      12
top      Ricky
freq         1

Verwenden Sie nun die folgende Anweisung und überprüfen Sie die Ausgabe -

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

Es ist output ist wie folgt -

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

Um die Funktionen Ihrer eigenen oder einer anderen Bibliothek auf Pandas-Objekte anzuwenden, sollten Sie die drei wichtigen Methoden kennen. Die Methoden wurden unten diskutiert. Die geeignete Methode hängt davon ab, ob Ihre Funktion einen gesamten DataFrame, zeilen- oder spaltenweise oder elementweise ausführen soll.

Tabelle weise Funktion Anwendung: pipe ()
Zeilen- oder spaltenweise Funktionsanwendung: apply ()
Elementweise Funktion Anwendung: applymap ()

Tabellenweise Funktionsanwendung

Benutzerdefinierte Operationen können ausgeführt werden, indem die Funktion und die entsprechende Anzahl von Parametern als Pipe-Argumente übergeben werden. Somit wird die Operation für den gesamten DataFrame ausgeführt.

Fügen Sie beispielsweise allen Elementen im DataFrame den Wert 2 hinzu. Dann,

Addiererfunktion

Die Addiererfunktion fügt zwei numerische Werte als Parameter hinzu und gibt die Summe zurück.

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

Wir werden nun die benutzerdefinierte Funktion verwenden, um Operationen am DataFrame durchzuführen.

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

Sehen wir uns das vollständige Programm an -

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)

Es ist output ist wie folgt -

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

Zeilen- oder spaltenweise Funktionsanwendung

Mit dem können beliebige Funktionen entlang der Achsen eines DataFrames oder Panels angewendet werden apply()Methode, die wie die deskriptiven Statistikmethoden ein optionales Achsenargument verwendet. Standardmäßig wird die Operation spaltenweise ausgeführt, wobei jede Spalte als Array-ähnlich betrachtet wird.

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

Es ist output ist wie folgt -

col1   -0.288022
col2    1.044839
col3   -0.187009
dtype: float64

Durch vorbei axis Parameter können Operationen zeilenweise ausgeführt werden.

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

Es ist output ist wie folgt -

col1    0.034093
col2   -0.152672
col3   -0.229728
dtype: float64

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

Es ist output ist wie folgt -

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

Elementweise Funktionsanwendung

Nicht alle Funktionen können vektorisiert werden (weder die NumPy-Arrays, die ein anderes Array zurückgeben, noch ein Wert), die Methoden applymap() auf DataFrame und analogously map() on Series akzeptiert alle Python-Funktionen, die einen einzelnen Wert annehmen und einen einzelnen Wert zurückgeben.

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

Es ist output ist wie folgt -

col1    0.480742
col2    0.454185
col3    0.266563
dtype: float64

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

Es ist output ist wie folgt -

col1    0.395263
col2    0.204418
col3   -0.795188
dtype: float64

ReindexingÄndert die Zeilen- und Spaltenbeschriftungen eines DataFrame. Indizieren Mittel , um die Daten anzupassen entlang einer bestimmten Achse einen gegebenen Satz von Etiketten zu entsprechen.

Mehrere Operationen können durch Indizieren wie - ausgeführt werden.

Ordnen Sie die vorhandenen Daten neu an, damit sie mit einem neuen Satz von Beschriftungen übereinstimmen.
Fügen Sie Markierungen für fehlende Werte (NA) an Etikettenpositionen ein, an denen keine Daten für das Etikett vorhanden waren.

Beispiel

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

Es ist output ist wie folgt -

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

Neu indizieren, um sich an anderen Objekten auszurichten

Möglicherweise möchten Sie ein Objekt nehmen und seine Achsen neu indizieren, um sie mit einem anderen Objekt zu kennzeichnen. Betrachten Sie das folgende Beispiel, um dasselbe zu verstehen.

Beispiel

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

Es ist output ist wie folgt -

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 - Hier die df1 DataFrame wird wie geändert und neu indiziert df2. Die Spaltennamen sollten übereinstimmen, da sonst NAN für die gesamte Spaltenbezeichnung hinzugefügt wird.

Füllen beim ReIndexieren

reindex() verwendet eine optionale Parametermethode, bei der es sich um eine Füllmethode mit den folgenden Werten handelt:

pad/ffill - Werte vorwärts füllen
bfill/backfill - Werte rückwärts füllen
nearest - Füllen Sie aus den nächsten Indexwerten

Beispiel

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

Es ist output ist wie folgt -

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 - Die letzten vier Zeilen sind gepolstert.

Beschränkungen beim Befüllen beim Neuindizieren

Das Argument limit bietet zusätzliche Kontrolle über das Füllen während der Neuindizierung. Limit gibt die maximale Anzahl aufeinanderfolgender Übereinstimmungen an. Betrachten wir das folgende Beispiel, um dasselbe zu verstehen:

Beispiel

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)

Es ist output ist wie folgt -

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- Beachten Sie, dass nur die 7. Reihe von der vorhergehenden 6. Reihe ausgefüllt wird. Dann bleiben die Zeilen unverändert.

Umbenennung

Mit der Methode rename () können Sie eine Achse basierend auf einer Zuordnung (einem Diktat oder einer Serie) oder einer beliebigen Funktion neu beschriften.

Betrachten wir das folgende Beispiel, um dies zu verstehen:

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

Es ist output ist wie folgt -

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

Die Methode rename () bietet eine inplacebenannter Parameter, der standardmäßig False ist und die zugrunde liegenden Daten kopiert. Besteheninplace=True um die Daten an Ort und Stelle umzubenennen.

Das Verhalten der grundlegenden Iteration über Pandas-Objekte hängt vom Typ ab. Wenn Sie über eine Serie iterieren, wird dies als Array-ähnlich angesehen, und die grundlegende Iteration erzeugt die Werte. Andere Datenstrukturen wie DataFrame und Panel folgen demdict-like Konvention der Iteration über die keys der Objekte.

Kurz gesagt, grundlegende Iteration (z i im Objekt) erzeugt -

Series - Werte
DataFrame - Spaltenbeschriftungen
Panel - Artikeletiketten

Iterieren eines DataFrame

Das Iterieren eines DataFrame gibt Spaltennamen an. Betrachten wir das folgende Beispiel, um dasselbe zu verstehen.

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

Es ist output ist wie folgt -

A
C
D
x
y

Um die Zeilen des DataFrame zu durchlaufen, können Sie die folgenden Funktionen verwenden:

iteritems() - um über die (Schlüssel-, Wert-) Paare zu iterieren
iterrows() - Durchlaufen Sie die Zeilen als (Index-, Serien-) Paare
itertuples() - als Namedtuples über die Zeilen iterieren

iteritems ()

Iteriert über jede Spalte als Schlüssel, Wertepaar mit Beschriftung als Schlüssel und Spaltenwert als Serienobjekt.

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

Es ist output ist wie folgt -

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

Beachten Sie, dass jede Spalte separat als Schlüssel-Wert-Paar in einer Reihe iteriert wird.

iterrows ()

iterrows () gibt den Iterator zurück, der jeden Indexwert zusammen mit einer Reihe mit den Daten in jeder Zeile liefert.

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

Es ist output ist wie folgt -

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 - Weil iterrows()Durchlaufen Sie die Zeilen, ohne den Datentyp in der Zeile beizubehalten. 0,1,2 sind die Zeilenindizes und col1, col2, col3 sind Spaltenindizes.

itertuples ()

Die Methode itertuples () gibt einen Iterator zurück, der für jede Zeile im DataFrame ein benanntes Tupel liefert. Das erste Element des Tupels ist der entsprechende Indexwert der Zeile, während die verbleibenden Werte die Zeilenwerte sind.

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

Es ist output ist wie folgt -

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- Versuchen Sie nicht, während der Iteration ein Objekt zu ändern. Das Iterieren ist zum Lesen gedacht und der Iterator gibt eine Kopie des Originalobjekts (eine Ansicht) zurück, sodass sich die Änderungen nicht auf das Originalobjekt auswirken.

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

Es ist output ist wie folgt -

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

Beachten Sie, keine Änderungen reflektiert.

In Pandas gibt es zwei Arten der Sortierung. Sie sind -

Nach Etikett
Nach tatsächlichem Wert

Betrachten wir ein Beispiel mit einer Ausgabe.

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

Es ist output ist wie folgt -

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

Im unsorted_df, das labels und die valuessind unsortiert. Lassen Sie uns sehen, wie diese sortiert werden können.

Nach Etikett

Verwendung der sort_index()Durch Übergeben der Achsenargumente und der Sortierreihenfolge kann DataFrame sortiert werden. Standardmäßig erfolgt die Sortierung nach Zeilenbeschriftungen in aufsteigender Reihenfolge.

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

Es ist output ist wie folgt -

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

Sortierreihenfolge

Durch Übergeben des Booleschen Werts an den aufsteigenden Parameter kann die Reihenfolge der Sortierung gesteuert werden. Betrachten wir das folgende Beispiel, um dasselbe zu verstehen.

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

Es ist output ist wie folgt -

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

Sortieren Sie die Spalten

Durch Übergeben des Achsenarguments mit dem Wert 0 oder 1 kann die Sortierung nach den Spaltenbeschriftungen erfolgen. Standardmäßig ist Achse = 0, nach Zeile sortieren. Betrachten wir das folgende Beispiel, um dasselbe zu verstehen.

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

Es ist output ist wie folgt -

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

Nach Wert

Wie die Indexsortierung, sort_values()ist die Methode zum Sortieren nach Werten. Es akzeptiert ein 'by'-Argument, das den Spaltennamen des DataFrame verwendet, mit dem die Werte sortiert werden sollen.

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

Es ist output ist wie folgt -

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

Beachten Sie, dass die Werte für col1 sortiert sind und sich der jeweilige Wert für col2 und der Zeilenindex zusammen mit col1 ändern. Sie sehen also unsortiert aus.

'by' Argument nimmt eine Liste von Spaltenwerten.

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

Es ist output ist wie folgt -

Sortieralgorithmus

sort_values()bietet eine Möglichkeit, den Algorithmus aus Mergesort, Heapsort und Quicksort auszuwählen. Mergesort ist der einzige stabile Algorithmus.

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

Es ist output ist wie folgt -

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

In diesem Kapitel werden wir die Zeichenfolgenoperationen mit unserer Basisreihe / unserem Index diskutieren. In den folgenden Kapiteln erfahren Sie, wie Sie diese Zeichenfolgenfunktionen auf den DataFrame anwenden.

Pandas bietet eine Reihe von Zeichenfolgenfunktionen, die die Bearbeitung von Zeichenfolgendaten vereinfachen. Am wichtigsten ist, dass diese Funktionen fehlende / NaN-Werte ignorieren (oder ausschließen).

Fast alle diese Methoden funktionieren mit Python-String-Funktionen (siehe: https://docs.python.org/3/library/stdtypes.html#string-methods). Konvertieren Sie also das Serienobjekt in ein Zeichenfolgenobjekt und führen Sie die Operation aus.

Lassen Sie uns nun sehen, wie jede Operation ausgeführt wird.

Sr.Nr.	Bedienungsanleitung
1	lower() Konvertiert Zeichenfolgen in der Serie / im Index in Kleinbuchstaben.
2	upper() Konvertiert Zeichenfolgen in der Serie / im Index in Großbuchstaben.
3	len() Berechnet die Stringlänge ().
4	strip() Hilft dabei, Leerzeichen (einschließlich Zeilenumbrüche) von beiden Zeichenfolgen in der Reihe / im Index von beiden Seiten zu entfernen.
5	split(' ') Teilt jede Zeichenfolge mit dem angegebenen Muster.
6	cat(sep=' ') Verkettet die Serien- / Indexelemente mit dem angegebenen Trennzeichen.
7	get_dummies() Gibt den DataFrame mit One-Hot-Encoded-Werten zurück.
8	contains(pattern) Gibt für jedes Element einen booleschen Wert True zurück, wenn die Teilzeichenfolge im Element enthalten ist, andernfalls False.
9	replace(a,b) Ersetzt den Wert a mit dem Wert b.
10	repeat(value) Wiederholt jedes Element mit der angegebenen Anzahl von Malen.
11	count(pattern) Gibt die Anzahl der Erscheinungen des Musters in jedem Element zurück.
12	startswith(pattern) Gibt true zurück, wenn das Element in der Serie / im Index mit dem Muster beginnt.
13	endswith(pattern) Gibt true zurück, wenn das Element in der Reihe / im Index mit dem Muster endet.
14	find(pattern) Gibt die erste Position des ersten Auftretens des Musters zurück.
15	findall(pattern) Gibt eine Liste aller Vorkommen des Musters zurück.
16	swapcase Vertauscht das Gehäuse unten / oben.
17	islower() Überprüft, ob alle Zeichen in jeder Zeichenfolge in der Reihe / im Index in Kleinbuchstaben geschrieben sind oder nicht. Gibt Boolean zurück
18	isupper() Überprüft, ob alle Zeichen in jeder Zeichenfolge in der Reihe / im Index in Großbuchstaben geschrieben sind oder nicht. Gibt Boolean zurück.
19	isnumeric() Überprüft, ob alle Zeichen in jeder Zeichenfolge in der Serie / im Index numerisch sind. Gibt Boolean zurück.

Lassen Sie uns nun eine Reihe erstellen und sehen, wie alle oben genannten Funktionen funktionieren.

import pandas as pd
import numpy as np

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

print s

Es ist output ist wie folgt -

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

niedriger()

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

Es ist output ist wie folgt -

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

Oberer, höher()

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

Es ist output ist wie folgt -

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

Es ist output ist wie folgt -

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

Streifen()

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

Es ist output ist wie folgt -

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

Split (Muster)

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

Es ist output ist wie folgt -

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

Katze (sep = Muster)

import pandas as pd
import numpy as np

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

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

Es ist output ist wie folgt -

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

Es ist output ist wie folgt -

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

enthält ()

import pandas as pd

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

print s.str.contains(' ')

Es ist output ist wie folgt -

0   True
1   True
2   False
3   False
dtype: bool

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

Es ist output ist wie folgt -

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

wiederholen (Wert)

import pandas as pd

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

print s.str.repeat(2)

Es ist output ist wie folgt -

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

Anzahl (Muster)

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

Es ist output ist wie folgt -

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

Start mit (Muster)

import pandas as pd

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

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

Es ist output ist wie folgt -

0  True
1  False
2  False
3  False
dtype: bool

endet mit (Muster)

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

Es ist output ist wie folgt -

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

find (Muster)

import pandas as pd

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

print s.str.find('e')

Es ist output ist wie folgt -

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

"-1" zeigt an, dass im Element kein solches Muster verfügbar ist.

findall (Muster)

import pandas as pd

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

print s.str.findall('e')

Es ist output ist wie folgt -

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

Die Nullliste ([]) zeigt an, dass im Element kein solches Muster verfügbar ist.

Swapcase ()

import pandas as pd

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

Es ist output ist wie folgt -

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

ist tiefer()

import pandas as pd

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

Es ist output ist wie folgt -

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

Es ist output ist wie folgt -

0  False
1  False
2  False
3  False
dtype: bool

isnumerisch ()

import pandas as pd

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

print s.str.isnumeric()

Es ist output ist wie folgt -

0  False
1  False
2  False
3  False
dtype: bool

Pandas bieten eine API, um einige Aspekte ihres Verhaltens anzupassen. Die Anzeige wird hauptsächlich verwendet.

Die API besteht aus fünf relevanten Funktionen. Sie sind -

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

Lassen Sie uns nun verstehen, wie die Funktionen funktionieren.

get_option (param)

get_option verwendet einen einzelnen Parameter und gibt den in der folgenden Ausgabe angegebenen Wert zurück -

display.max_rows

Zeigt die Standardwertzahl an. Der Interpreter liest diesen Wert und zeigt die Zeilen mit diesem Wert als Obergrenze für die Anzeige an.

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

Es ist output ist wie folgt -

display.max_columns

Zeigt die Standardwertzahl an. Der Interpreter liest diesen Wert und zeigt die Zeilen mit diesem Wert als Obergrenze für die Anzeige an.

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

Es ist output ist wie folgt -

Hier sind 60 und 20 die Standardwerte für die Konfigurationsparameter.

set_option (param, value)

set_option verwendet zwei Argumente und setzt den Wert wie unten gezeigt auf den Parameter -

display.max_rows

Verwenden von set_option()können wir die Standardanzahl der anzuzeigenden Zeilen ändern.

import pandas as pd

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

print pd.get_option("display.max_rows")

Es ist output ist wie folgt -

display.max_columns

Verwenden von set_option()können wir die Standardanzahl der anzuzeigenden Zeilen ändern.

import pandas as pd

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

print pd.get_option("display.max_columns")

Es ist output ist wie folgt -

reset_option (param)

reset_option Nimmt ein Argument und setzt den Wert auf den Standardwert zurück.

display.max_rows

Mit reset_option () können wir den Wert auf die Standardanzahl der anzuzeigenden Zeilen zurücksetzen.

import pandas as pd

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

Es ist output ist wie folgt -

description_option (param)

describe_option druckt die Beschreibung des Arguments.

display.max_rows

Mit reset_option () können wir den Wert auf die Standardanzahl der anzuzeigenden Zeilen zurücksetzen.

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

Es ist output ist wie folgt -

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

Mit dem Kontextmanager option_context wird die Option in festgelegt with statementvorübergehend. Optionswerte werden beim Beenden von automatisch wiederhergestelltwith block - -

display.max_rows

Mit option_context () können wir den Wert vorübergehend festlegen.

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

Es ist output ist wie folgt -

10
10

Siehe den Unterschied zwischen der ersten und der zweiten Druckanweisung. Die erste Anweisung gibt den von festgelegten Wert ausoption_context() das ist vorübergehend innerhalb der with contextselbst. Nach demwith contextDie zweite Druckanweisung gibt den konfigurierten Wert aus.

Häufig verwendete Parameter

Sr.Nr.	Parameter & Beschreibung
1	display.max_rows Zeigt die maximale Anzahl der anzuzeigenden Zeilen an
2	2 display.max_columns Zeigt die maximale Anzahl der anzuzeigenden Spalten an
3	display.expand_frame_repr Zeigt DataFrames zum Strecken von Seiten an
4	display.max_colwidth Zeigt die maximale Spaltenbreite an
5	display.precision Zeigt die Genauigkeit für Dezimalzahlen an

In diesem Kapitel werden wir diskutieren, wie man das Datum schneidet und würfelt und im Allgemeinen die Teilmenge des Pandas-Objekts erhält.

Die Python- und NumPy-Indexierungsoperatoren "[]" und der Attributoperator "." Bieten Sie schnellen und einfachen Zugriff auf Pandas-Datenstrukturen in einer Vielzahl von Anwendungsfällen. Da jedoch die Art der Daten, auf die zugegriffen werden soll, nicht im Voraus bekannt ist, hat die direkte Verwendung von Standardoperatoren einige Optimierungsgrenzen. Für den Produktionscode empfehlen wir, die in diesem Kapitel erläuterten optimierten Pandas-Datenzugriffsmethoden zu nutzen.

Pandas unterstützt jetzt drei Arten der Mehrachsen-Indizierung. Die drei Typen sind in der folgenden Tabelle aufgeführt -

Sr.Nr.	Indizierung & Beschreibung
1	.loc() Etikettenbasiert
2	.iloc() Ganzzahl basiert
3	.ix() Sowohl Label- als auch Integer-basiert

.loc ()

Pandas bieten verschiedene Methoden, um rein zu haben label based indexing. Beim Schneiden wird auch die Startgrenze berücksichtigt. Ganzzahlen sind gültige Beschriftungen, beziehen sich jedoch auf die Beschriftung und nicht auf die Position.

.loc() hat mehrere Zugriffsmethoden wie -

Eine einzelne skalare Bezeichnung
Eine Liste der Etiketten
Ein Slice-Objekt
Ein boolesches Array

locNimmt zwei Einzel- / Listen- / Bereichsoperatoren, die durch ',' getrennt sind. Die erste gibt die Zeile und die zweite die Spalten an.

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

Beispiel 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

Es ist output ist wie folgt -

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

.iloc ()

Pandas bieten verschiedene Methoden, um eine rein ganzzahlige Indizierung zu erhalten. Wie Python und Numpy sind dies0-based Indizierung.

Die verschiedenen Zugriffsmethoden sind wie folgt:

Eine ganze Zahl
Eine Liste von ganzen Zahlen
Ein Wertebereich

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

Neben reinen Label-basierten und Integer-basierten bietet Pandas eine Hybridmethode zum Auswählen und Unterteilen des Objekts mit dem Operator .ix ().

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

Verwendung von Notationen

Das Abrufen von Werten aus dem Pandas-Objekt mit der Mehrachsen-Indizierung verwendet die folgende Notation:

Objekt	Indexer	Rückgabetyp
Serie	s.loc [Indexer]	Skalarwert
DataFrame	df.loc [row_index, col_index]	Serienobjekt
Panel	p.loc [item_index, major_index, minor_index]	p.loc [item_index, major_index, minor_index]

Note − .iloc() & .ix() Wendet die gleichen Indizierungsoptionen und den gleichen Rückgabewert an.

Lassen Sie uns nun sehen, wie jede Operation für das DataFrame-Objekt ausgeführt werden kann. Wir werden den grundlegenden Indexierungsoperator '[]' verwenden -

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

Es ist output ist wie folgt -

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 - Wir können eine Liste von Werten an [] übergeben, um diese Spalten auszuwählen.

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

Attributzugriff

Spalten können mit dem Attributoperator '.' Ausgewählt werden.

Beispiel

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

print df.A

Es ist output ist wie folgt -

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

Statistische Methoden helfen beim Verständnis und der Analyse des Verhaltens von Daten. Wir werden nun einige statistische Funktionen lernen, die wir auf Pandas-Objekte anwenden können.

Prozentänderung

Serien, DatFrames und Panel haben alle die Funktion pct_change(). Diese Funktion vergleicht jedes Element mit seinem vorherigen Element und berechnet den Änderungsprozentsatz.

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

Es ist output ist wie folgt -

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

Standardmäßig ist die pct_change()arbeitet mit Spalten; Wenn Sie dieselbe Zeile weise anwenden möchten, verwenden Sieaxis=1() Streit.

Kovarianz

Die Kovarianz wird auf Seriendaten angewendet. Das Serienobjekt verfügt über eine Methode cov, um die Kovarianz zwischen Serienobjekten zu berechnen. NA wird automatisch ausgeschlossen.

Cov-Serie

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)

Es ist output ist wie folgt -

-0.12978405324

Die Kovarianzmethode wird berechnet, wenn sie auf einen DataFrame angewendet wird cov zwischen allen Spalten.

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

Es ist output ist wie folgt -

-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 - Beachten Sie die cov zwischen a und b Spalte in der ersten Anweisung und das gleiche ist der Wert, der von cov auf DataFrame zurückgegeben wird.

Korrelation

Die Korrelation zeigt die lineare Beziehung zwischen zwei beliebigen Wertearrays (Reihen). Es gibt mehrere Methoden zur Berechnung der Korrelation wie Pearson (Standard), Spearman und 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()

Es ist output ist wie folgt -

-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

Wenn im DataFrame eine nicht numerische Spalte vorhanden ist, wird diese automatisch ausgeschlossen.

Datenranking

Das Datenranking erzeugt ein Ranking für jedes Element im Array von Elementen. Weist bei Gleichstand den mittleren Rang zu.

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

Es ist output ist wie folgt -

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

Der Rang nimmt optional einen aufsteigenden Parameter an, der standardmäßig wahr ist. Wenn false, werden die Daten umgekehrt eingestuft, wobei größeren Werten ein kleinerer Rang zugewiesen wird.

Rank unterstützt verschiedene Tie-Breaking-Methoden, die mit dem Methodenparameter - angegeben werden.

average - durchschnittlicher Rang der gebundenen Gruppe
min - niedrigster Rang in der Gruppe
max - höchster Rang in der Gruppe
first - Ränge in der Reihenfolge zugewiesen, in der sie im Array angezeigt werden

Für die Bearbeitung numerischer Daten bieten Pandas nur wenige Varianten wie Rollen, Erweitern und exponentielles Bewegen von Gewichten für Fensterstatistiken. Unter diesen sindsum, mean, median, variance, covariance, correlation, usw.

Wir werden nun lernen, wie diese auf DataFrame-Objekte angewendet werden können.

.rolling () Funktion

Diese Funktion kann auf eine Reihe von Daten angewendet werden. Präzisiere daswindow=n argumentieren und die entsprechende statistische Funktion darüber anwenden.

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

Es ist output ist wie folgt -

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 - Da die Fenstergröße 3 ist, gibt es für die ersten beiden Elemente Nullen und ab dem dritten ist der Wert der Durchschnitt der n, n-1 und n-2Elemente. Somit können wir auch verschiedene Funktionen anwenden, wie oben erwähnt.

.expanding () Funktion

Diese Funktion kann auf eine Reihe von Daten angewendet werden. Präzisiere dasmin_periods=n argumentieren und die entsprechende statistische Funktion darüber anwenden.

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

Es ist output ist wie folgt -

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

ewmwird auf eine Reihe von Daten angewendet. Geben Sie eine der folgenden Optionen an: com, span,halflifeargumentieren und die entsprechende statistische Funktion darüber anwenden. Es weist die Gewichte exponentiell zu.

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

Es ist output ist wie folgt -

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

Fensterfunktionen werden hauptsächlich verwendet, um die Trends innerhalb der Daten grafisch zu finden, indem die Kurve geglättet wird. Wenn die alltäglichen Daten sehr unterschiedlich sind und viele Datenpunkte verfügbar sind, ist das Entnehmen der Proben und das Zeichnen eine Methode und das Anwenden der Fensterberechnungen und das Zeichnen des Diagramms auf die Ergebnisse eine andere Methode. Mit diesen Methoden können wir die Kurve oder den Trend glätten.

Sobald das Rollen, Erweitern und ewm Objekte erstellt werden, stehen verschiedene Methoden zur Verfügung, um Aggregationen an Daten durchzuführen.

Anwenden von Aggregationen auf DataFrame

Lassen Sie uns einen DataFrame erstellen und Aggregationen darauf anwenden.

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

Es ist output ist wie folgt -

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]

Wir können aggregieren, indem wir eine Funktion an den gesamten DataFrame übergeben oder eine Spalte über den Standard auswählen get item Methode.

Wenden Sie die Aggregation auf einen gesamten Datenrahmen an

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)

Es ist output ist wie folgt -

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

Wenden Sie die Aggregation auf eine einzelne Spalte eines Datenrahmens an

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)

Es ist output ist wie folgt -

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

Wenden Sie die Aggregation auf mehrere Spalten eines DataFrames an

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)

Es ist output ist wie folgt -

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

Wenden Sie mehrere Funktionen auf eine einzelne Spalte eines DataFrames an

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

Es ist output ist wie folgt -

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

Wenden Sie mehrere Funktionen auf mehrere Spalten eines DataFrames an

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

Es ist output ist wie folgt -

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

Wenden Sie verschiedene Funktionen auf verschiedene Spalten eines Datenrahmens an

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

Es ist output ist wie folgt -

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

Fehlende Daten sind in realen Szenarien immer ein Problem. Bereiche wie maschinelles Lernen und Data Mining sind aufgrund der schlechten Datenqualität aufgrund fehlender Werte mit schwerwiegenden Problemen bei der Genauigkeit ihrer Modellvorhersagen konfrontiert. In diesen Bereichen steht die Behandlung fehlender Werte im Vordergrund, um ihre Modelle genauer und valider zu machen.

Wann und warum fehlen Daten?

Betrachten wir eine Online-Umfrage für ein Produkt. Oft teilen die Leute nicht alle Informationen, die mit ihnen zusammenhängen. Nur wenige Menschen teilen ihre Erfahrungen, aber nicht, wie lange sie das Produkt verwenden. Nur wenige Personen teilen mit, wie lange sie das Produkt verwenden, welche Erfahrungen sie gemacht haben, aber nicht ihre Kontaktinformationen. Auf die eine oder andere Weise fehlt also immer ein Teil der Daten, und dies ist in Echtzeit sehr häufig.

Lassen Sie uns nun sehen, wie wir mit fehlenden Werten (z. B. NA oder NaN) mit Pandas umgehen können.

# 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

Es ist output ist wie folgt -

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

Mit der Neuindizierung haben wir einen DataFrame mit fehlenden Werten erstellt. In der AusgabeNaN meint Not a Number.

Überprüfen Sie, ob Werte fehlen

Um das Erkennen fehlender Werte (und über verschiedene Array-D-Typen hinweg) zu vereinfachen, bietet Pandas die isnull() und notnull() Funktionen, die auch Methoden für Serien- und DataFrame-Objekte sind -

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

Berechnungen mit fehlenden Daten

Beim Summieren von Daten wird NA als Null behandelt
Wenn die Daten alle NA sind, ist das Ergebnis NA

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

Es ist output ist wie folgt -

2.02357685917

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

Es ist output ist wie folgt -

nan

Fehlende Daten bereinigen / füllen

Pandas bietet verschiedene Methoden zum Reinigen der fehlenden Werte. Die Fillna-Funktion kann NA-Werte auf verschiedene Weise mit Nicht-Null-Daten „füllen“, wie in den folgenden Abschnitten dargestellt.

Ersetzen Sie NaN durch einen Skalarwert

Das folgende Programm zeigt, wie Sie "NaN" durch "0" ersetzen können.

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)

Es ist output ist wie folgt -

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

Hier füllen wir mit dem Wert Null; Stattdessen können wir auch mit jedem anderen Wert füllen.

Füllen Sie NA vorwärts und rückwärts

Mit den im Kapitel ReIndexing beschriebenen Füllkonzepten werden die fehlenden Werte gefüllt.

Sr.Nr.	Methode & Aktion
1	pad/fill Füllmethoden Weiterleiten
2	bfill/backfill Füllmethoden rückwärts

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

Fehlende Werte löschen

Wenn Sie die fehlenden Werte einfach ausschließen möchten, verwenden Sie die dropna Funktion zusammen mit dem axisStreit. Standardmäßig ist Achse = 0, dh entlang der Zeile. Wenn also ein Wert innerhalb einer Zeile NA ist, wird die gesamte Zeile ausgeschlossen.

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

Ersetzen Sie fehlende (oder) generische Werte

Oft müssen wir einen generischen Wert durch einen bestimmten Wert ersetzen. Wir können dies erreichen, indem wir die Ersetzungsmethode anwenden.

Das Ersetzen von NA durch einen Skalarwert entspricht dem Verhalten von fillna() Funktion.

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

Es ist output ist wie folgt -

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

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

Es ist output ist wie folgt -

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

Irgendein groupbyDie Operation umfasst eine der folgenden Operationen für das ursprüngliche Objekt. Sie sind -

Splitting das Objekt
Applying eine Funktion
Combining die Ergebnisse

In vielen Situationen teilen wir die Daten in Mengen auf und wenden auf jede Teilmenge einige Funktionen an. In der Apply-Funktionalität können wir die folgenden Operationen ausführen:

Aggregation - Berechnung einer zusammenfassenden Statistik
Transformation - eine gruppenspezifische Operation ausführen
Filtration - Verwerfen der Daten unter bestimmten Bedingungen

Lassen Sie uns nun ein DataFrame-Objekt erstellen und alle Operationen daran ausführen -

#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

Es ist output ist wie folgt -

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

Daten in Gruppen aufteilen

Pandas-Objekte können in jedes ihrer Objekte aufgeteilt werden. Es gibt mehrere Möglichkeiten, ein Objekt wie - zu teilen.

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

Lassen Sie uns nun sehen, wie die Gruppierungsobjekte auf das DataFrame-Objekt angewendet werden können

Beispiel

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

Es ist output ist wie folgt -

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

Gruppen anzeigen

# 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

Es ist output ist wie folgt -

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

Beispiel

Group by mit mehreren Spalten -

# 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

Es ist output ist wie folgt -

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

Durch Gruppen iterieren

Mit dem groupby Objekt in der Hand, können wir durch das Objekt iterieren, ähnlich wie 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

Es ist output ist wie folgt -

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

Standardmäßig ist die groupby Objekt hat den gleichen Beschriftungsnamen wie der Gruppenname.

Wählen Sie eine Gruppe aus

Verwendung der get_group() Methode können wir eine einzelne Gruppe auswählen.

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

Es ist output ist wie folgt -

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

Aggregationen

Eine aggregierte Funktion gibt für jede Gruppe einen einzelnen aggregierten Wert zurück. Sobald diegroup by Wenn ein Objekt erstellt wird, können mehrere Aggregationsvorgänge für die gruppierten Daten ausgeführt werden.

Eine offensichtliche ist die Aggregation über das Aggregat oder ein Äquivalent agg Methode -

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

Es ist output ist wie folgt -

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

Eine andere Möglichkeit, die Größe jeder Gruppe zu ermitteln, besteht darin, die Funktion size () anzuwenden.

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)

Es ist output ist wie folgt -

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

Anwenden mehrerer Aggregationsfunktionen gleichzeitig

Bei gruppierten Serien können Sie auch eine übergeben list oder dict of functions Aggregation mit und Generieren von DataFrame als Ausgabe -

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

Es ist output ist wie folgt -

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

Transformationen

Die Transformation für eine Gruppe oder eine Spalte gibt ein Objekt zurück, das indiziert ist und dieselbe Größe hat wie das, das gruppiert wird. Daher sollte die Transformation ein Ergebnis zurückgeben, das dieselbe Größe wie das eines Gruppenblocks hat.

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

Es ist output ist wie folgt -

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

Filtration

Die Filterung filtert die Daten nach definierten Kriterien und gibt die Teilmenge der Daten zurück. Dasfilter() Funktion wird verwendet, um die Daten zu filtern.

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)

Es ist output ist wie folgt -

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

In der obigen Filterbedingung bitten wir Sie, die Teams zurückzugeben, die drei oder mehr Mal an IPL teilgenommen haben.

Pandas verfügt über leistungsstarke In-Memory-Join-Vorgänge mit vollem Funktionsumfang, die relationalen Datenbanken wie SQL idiomatisch sehr ähnlich sind.

Pandas bietet eine einzige Funktion: merge, als Einstiegspunkt für alle Standard-Datenbankverbindungsvorgänge zwischen DataFrame-Objekten -

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

Hier haben wir die folgenden Parameter verwendet -

left - Ein DataFrame-Objekt.
right - Ein weiteres DataFrame-Objekt.
on- Spalten (Namen), an denen Sie teilnehmen möchten. Muss sowohl im linken als auch im rechten DataFrame-Objekt gefunden werden.
left_on- Spalten aus dem linken DataFrame, die als Schlüssel verwendet werden sollen. Kann entweder Spaltennamen oder Arrays sein, deren Länge der Länge des DataFrame entspricht.
right_on- Spalten aus dem rechten DataFrame, die als Schlüssel verwendet werden sollen. Kann entweder Spaltennamen oder Arrays sein, deren Länge der Länge des DataFrame entspricht.
left_index - Wenn True,Verwenden Sie den Index (Zeilenbeschriftungen) aus dem linken DataFrame als Join-Schlüssel. Bei einem DataFrame mit einem MultiIndex (hierarchisch) muss die Anzahl der Ebenen mit der Anzahl der Join-Schlüssel des rechten DataFrame übereinstimmen.
right_index - Gleiche Verwendung wie left_index für den richtigen DataFrame.
how- Eine von "links", "rechts", "außen", "innen". Der Standardwert ist inner. Jede Methode wurde unten beschrieben.
sort- Sortieren Sie das Ergebnis DataFrame nach den Verknüpfungsschlüsseln in lexikografischer Reihenfolge. Der Standardwert ist True. Wenn Sie den Wert auf False setzen, wird die Leistung in vielen Fällen erheblich verbessert.

Lassen Sie uns nun zwei verschiedene DataFrames erstellen und die Zusammenführungsvorgänge ausführen.

# 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

Es ist output ist wie folgt -

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

Führen Sie zwei DataFrames auf einem Schlüssel zusammen

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

Es ist output ist wie folgt -

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

Führen Sie zwei DataFrames auf mehreren Schlüsseln zusammen

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

Es ist output ist wie folgt -

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

Zusammenführen mit dem Argument 'wie'

Das howDas zusammenzuführende Argument gibt an, wie bestimmt wird, welche Schlüssel in die resultierende Tabelle aufgenommen werden sollen. Wenn eine Tastenkombination weder in der linken noch in der rechten Tabelle angezeigt wird, sind die Werte in der verknüpften Tabelle NA.

Hier ist eine Zusammenfassung der how Optionen und ihre SQL-äquivalenten Namen -

Zusammenführungsmethode	SQL-Äquivalent	Beschreibung
links	LINKE ÄUSSERE VERBINDUNG	Verwenden Sie die Tasten des linken Objekts
Recht	RIGHT OUTER JOIN	Verwenden Sie Schlüssel vom rechten Objekt
äußere	VOLLSTÄNDIGER OUTER JOIN	Verwenden Sie die Vereinigung von Schlüsseln
innere	INNER JOIN	Verwenden Sie den Schnittpunkt der Schlüssel

Links beitreten

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

Es ist output ist wie folgt -

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

Es ist output ist wie folgt -

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

Äußere Verbindung

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

Es ist output ist wie folgt -

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

Inner Join

Die Verknüpfung wird für den Index durchgeführt. Die Verknüpfungsoperation berücksichtigt das Objekt, für das sie aufgerufen wird. Damit,a.join(b) ist ungleich zu 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')

Es ist output ist wie folgt -

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

Pandas bietet verschiedene Möglichkeiten zum einfachen Kombinieren Series, DataFrame, und Panel Objekte.

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

objs - Dies ist eine Sequenz oder Zuordnung von Serien-, DataFrame- oder Panel-Objekten.
axis - {0, 1, ...}, Standard 0. Dies ist die Achse, entlang der verkettet werden soll.
join- {'inner', 'äußere'}, Standard 'äußere'. Umgang mit Indizes auf anderen Achsen. Außen für Vereinigung und Innen für Kreuzung.
ignore_index- Boolescher Wert, Standardwert False. Wenn True, verwenden Sie nicht die Indexwerte auf der Verkettungsachse. Die resultierende Achse wird mit 0, ..., n - 1 bezeichnet.
join_axes- Dies ist die Liste der Indexobjekte. Spezifische Indizes, die für die anderen (n-1) Achsen verwendet werden sollen, anstatt die innere / äußere Mengenlogik auszuführen.

Objekte verketten

Das concatDie Funktion erledigt das gesamte schwere Heben der Durchführung von Verkettungsvorgängen entlang einer Achse. Lassen Sie uns verschiedene Objekte erstellen und Verkettungen durchführen.

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

Es ist output ist wie folgt -

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

Angenommen, wir wollten jedem Teil des zerhackten DataFrame bestimmte Schlüssel zuordnen. Wir können dies tun, indem wir diekeys 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'])

Es ist output ist wie folgt -

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

Der Index der Resultierenden wird dupliziert; Jeder Index wird wiederholt.

Wenn das resultierende Objekt einer eigenen Indizierung folgen muss, setzen Sie ignore_index zu 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)

Es ist output ist wie folgt -

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

Beachten Sie, dass sich der Index vollständig ändert und die Schlüssel ebenfalls überschrieben werden.

Wenn zwei Objekte hinzugefügt werden müssen axis=1Dann werden die neuen Spalten angehängt.

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)

Es ist output ist wie folgt -

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

Verketten mit Anhängen

Eine nützliche Verknüpfung zum Concat sind die Methoden zum Anhängen von Instanzen in Series und DataFrame. Diese Methoden waren tatsächlich älter als concat. Sie verketten sichaxis=0, nämlich der Index -

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)

Es ist output ist wie folgt -

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

Das append Funktion kann auch mehrere Objekte aufnehmen -

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

Es ist output ist wie folgt -

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

Zeitfolgen

Pandas bieten ein robustes Tool für die Arbeitszeit mit Zeitreihendaten, insbesondere im Finanzsektor. Bei der Arbeit mit Zeitreihendaten stoßen wir häufig auf Folgendes:

Zeitfolge erzeugen
Konvertieren Sie die Zeitreihen in verschiedene Frequenzen

Pandas bietet einen relativ kompakten und in sich geschlossenen Werkzeugsatz zur Ausführung der oben genannten Aufgaben.

Aktuelle Zeit abrufen

datetime.now() gibt Ihnen das aktuelle Datum und die Uhrzeit.

import pandas as pd

print pd.datetime.now()

Es ist output ist wie folgt -

2017-05-11 06:10:13.393147

Erstellen Sie einen Zeitstempel

Zeitstempeldaten sind die grundlegendste Art von Zeitreihendaten, die Werte mit Zeitpunkten verknüpfen. Für Pandas-Objekte bedeutet dies, die Zeitpunkte zu verwenden. Nehmen wir ein Beispiel -

import pandas as pd

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

Es ist output ist wie folgt -

2017-03-01 00:00:00

Es ist auch möglich, Epochenzeiten für Ganzzahlen oder Gleitkommazahlen zu konvertieren. Die Standardeinheit für diese ist Nanosekunden (da auf diese Weise Zeitstempel gespeichert werden). Oft werden Epochen jedoch in einer anderen Einheit gespeichert, die angegeben werden kann. Nehmen wir ein anderes Beispiel

import pandas as pd

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

Es ist output ist wie folgt -

2020-04-24 00:14:15

Erstellen Sie einen Zeitbereich

import pandas as pd

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

Es ist output ist wie folgt -

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

Ändern Sie die Häufigkeit der Zeit

import pandas as pd

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

Es ist output ist wie folgt -

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

Konvertieren in Zeitstempel

Um eine Serie oder ein listähnliches Objekt von datumsähnlichen Objekten zu konvertieren, z. B. Zeichenfolgen, Epochen oder eine Mischung, können Sie die verwenden to_datetimeFunktion. Bei Übergabe wird eine Serie (mit demselben Index) zurückgegeben, während alist-like wird in a umgewandelt DatetimeIndex. Schauen Sie sich das folgende Beispiel an -

import pandas as pd

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

Es ist output ist wie folgt -

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

NaT meint Not a Time (entspricht NaN)

Nehmen wir ein anderes Beispiel.

import pandas as pd

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

Es ist output ist wie folgt -

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

Bei der Erweiterung der Zeitreihen spielen Datumsfunktionalitäten eine wichtige Rolle bei der Analyse von Finanzdaten. Bei der Arbeit mit Datumsdaten werden wir häufig auf Folgendes stoßen:

Datumsfolge generieren
Konvertieren Sie die Datumsreihen in verschiedene Frequenzen

Erstellen Sie einen Datumsbereich

Verwendung der date.range()Funktion durch Angabe der Perioden und der Häufigkeit können wir die Datumsreihen erstellen. Standardmäßig beträgt die Häufigkeit des Bereichs Tage.

import pandas as pd

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

Es ist output ist wie folgt -

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

Ändern Sie die Datumshäufigkeit

import pandas as pd

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

Es ist output ist wie folgt -

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 () steht für Geschäftsdatumsbereiche. Im Gegensatz zu date_range () werden Samstag und Sonntag ausgeschlossen.

import pandas as pd

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

Es ist output ist wie folgt -

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

Beachten Sie, dass nach dem 3. März das Datum auf den 6. März ohne 4. und 5. März springt. Überprüfen Sie einfach Ihren Kalender für die Tage.

Komfort funktioniert wie date_range und bdate_rangeVerwenden Sie eine Vielzahl von Frequenzaliasen. Die Standardhäufigkeit für date_range ist ein Kalendertag, während die Standardhäufigkeit für bdate_range ein Geschäftstag ist.

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

print pd.date_range(start, end)

Es ist output ist wie folgt -

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

Versetzte Aliase

Eine Anzahl von String-Aliasen wird für nützliche gemeinsame Zeitreihenfrequenzen angegeben. Wir werden diese Aliase als Offset-Aliase bezeichnen.

Alias	Beschreibung	Alias	Beschreibung
B.	Häufigkeit von Werktagen	BQS	Starthäufigkeit des Geschäftsquartals
D.	Kalendertag Häufigkeit	EIN	jährliche (Jahres-) Endfrequenz
W.	wöchentliche Häufigkeit	BA	Häufigkeit zum Ende des Geschäftsjahres
M.	Häufigkeit zum Monatsende	BAS	Starthäufigkeit des Geschäftsjahres
SM	Halbmonatsendfrequenz	BH	Geschäftsstundenfrequenz
BM	Häufigkeit des Geschäftsmonatsendes	H.	Stundenfrequenz
MS	Starthäufigkeit des Monats	T, min	minutiöse Frequenz
SMS	Starthäufigkeit für SMS-Halbmonate	S.	zweitens Frequenz
BMS	Starthäufigkeit des Geschäftsmonats	L, ms	Millisekunden
Q.	Viertelendfrequenz	U, wir	Mikrosekunden
BQ	Häufigkeit des Geschäftsquartalsendes	N.	Nanosekunden
QS	viertel Startfrequenz

Zeitdeltas sind Zeitunterschiede, ausgedrückt in Differenzeinheiten, z. B. Tage, Stunden, Minuten, Sekunden. Sie können sowohl positiv als auch negativ sein.

Wir können Timedelta-Objekte mit verschiedenen Argumenten erstellen, wie unten gezeigt -

String

Durch Übergeben eines Zeichenfolgenliteral können wir ein Zeitdelta-Objekt erstellen.

import pandas as pd

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

Es ist output ist wie folgt -

2 days 02:15:30

Ganze Zahl

Durch Übergeben eines ganzzahligen Werts an die Einheit erstellt ein Argument ein Timedelta-Objekt.

import pandas as pd

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

Es ist output ist wie folgt -

0 days 06:00:00

Datenversätze

Datenversätze wie - Wochen, Tage, Stunden, Minuten, Sekunden, Millisekunden, Mikrosekunden, Nanosekunden können ebenfalls im Bauwesen verwendet werden.

import pandas as pd

print pd.Timedelta(days=2)

Es ist output ist wie folgt -

2 days 00:00:00

to_timedelta ()

Verwenden der obersten Ebene pd.to_timedeltakönnen Sie einen Skalar, ein Array, eine Liste oder eine Serie von einem erkannten Timedelta-Format / Wert in einen Timedelta-Typ konvertieren. Es wird eine Serie erstellt, wenn die Eingabe eine Serie ist, ein Skalar, wenn die Eingabe skalarartig ist, andernfalls wird a ausgegebenTimedeltaIndex.

import pandas as pd

print pd.Timedelta(days=2)

Es ist output ist wie folgt -

2 days 00:00:00

Operationen

Sie können Serien / DataFrames bearbeiten und konstruieren timedelta64[ns] Serie durch Subtraktionsoperationen auf datetime64[ns] Serien oder Zeitstempel.

Lassen Sie uns nun einen DataFrame mit Timedelta- und datetime-Objekten erstellen und einige arithmetische Operationen daran ausführen -

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

Es ist output ist wie folgt -

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

Additionsoperationen

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

Es ist output ist wie folgt -

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

Subtraktionsoperation

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

Es ist output ist wie folgt -

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

Oft enthalten Daten in Echtzeit die Textspalten, die sich wiederholen. Funktionen wie Geschlecht, Land und Codes wiederholen sich immer. Dies sind die Beispiele für kategoriale Daten.

Kategoriale Variablen können nur eine begrenzte und normalerweise feste Anzahl möglicher Werte annehmen. Neben der festen Länge können kategoriale Daten eine Reihenfolge haben, aber keine numerische Operation ausführen. Kategorisch sind ein Pandas-Datentyp.

Der kategoriale Datentyp ist in den folgenden Fällen nützlich:

Eine Zeichenfolgenvariable, die nur aus wenigen unterschiedlichen Werten besteht. Das Konvertieren einer solchen Zeichenfolgenvariablen in eine kategoriale Variable spart Speicherplatz.
Die lexikalische Reihenfolge einer Variablen entspricht nicht der logischen Reihenfolge ("eins", "zwei", "drei"). Durch die Konvertierung in eine Kategorie und die Angabe einer Reihenfolge in den Kategorien verwenden Sortierung und Min / Max die logische Reihenfolge anstelle der lexikalischen Reihenfolge.
Als Signal an andere Python-Bibliotheken, dass diese Spalte als kategoriale Variable behandelt werden sollte (z. B. um geeignete statistische Methoden oder Diagrammtypen zu verwenden).

Objekterstellung

Kategoriale Objekte können auf verschiedene Arten erstellt werden. Die verschiedenen Möglichkeiten wurden unten beschrieben -

Kategorie

Durch Angabe des D-Typs als "Kategorie" bei der Pandas-Objekterstellung.

import pandas as pd

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

Es ist output ist wie folgt -

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

Die Anzahl der an das Serienobjekt übergebenen Elemente beträgt vier, die Kategorien sind jedoch nur drei. Beachten Sie dies auch in den Ausgabekategorien.

pd.Categorical

Mit dem Standard-Pandas-Konstruktor "Kategorie" können wir ein Kategorieobjekt erstellen.

pandas.Categorical(values, categories, ordered)

Nehmen wir ein Beispiel -

import pandas as pd

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

Es ist output ist wie folgt -

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

Lassen Sie uns ein anderes Beispiel haben -

import pandas as pd

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

Es ist output ist wie folgt -

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

Hier bezeichnet das zweite Argument die Kategorien. Daher wird jeder Wert, der in den Kategorien nicht vorhanden ist, als behandeltNaN.

Schauen Sie sich nun das folgende Beispiel an:

import pandas as pd

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

Es ist output ist wie folgt -

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

Logischerweise bedeutet die Reihenfolge, dass a ist größer als b und b ist größer als c.

Beschreibung

Verwendung der .describe() Befehl für die kategorialen Daten erhalten wir eine ähnliche Ausgabe wie a Series oder DataFrame des type Zeichenfolge.

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

Es ist output ist wie folgt -

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

Rufen Sie die Eigenschaften der Kategorie ab

obj.cat.categories Befehl wird verwendet, um die zu erhalten 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

Es ist output ist wie folgt -

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

obj.ordered Befehl wird verwendet, um die Reihenfolge des Objekts abzurufen.

import pandas as pd
import numpy as np

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

Es ist output ist wie folgt -

False

Die Funktion wurde zurückgegeben false weil wir keine Reihenfolge angegeben haben.

Kategorien umbenennen

Das Umbenennen von Kategorien erfolgt durch Zuweisen neuer Werte zu series.cat.categoriesseries.cat.categories-Eigenschaft.

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

Es ist output ist wie folgt -

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

Anfangskategorien [a,b,c] werden von der aktualisiert s.cat.categories Eigentum des Objekts.

Neue Kategorien anhängen

Mit der Methode Categorical.add.categories () können neue Kategorien angehängt werden.

import pandas as pd

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

Es ist output ist wie folgt -

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

Kategorien entfernen

Verwendung der Categorical.remove_categories() Methode können unerwünschte Kategorien entfernt werden.

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

Es ist output ist wie folgt -

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]

Vergleich kategorialer Daten

Der Vergleich kategorialer Daten mit anderen Objekten ist in drei Fällen möglich:

Vergleichen der Gleichheit (== und! =) mit einem listenartigen Objekt (Liste, Serie, Array, ...) mit der gleichen Länge wie die kategorialen Daten.
Alle Vergleiche (== ,! =,>,> =, <und <=) von kategorialen Daten mit einer anderen kategorialen Reihe, wenn geordnet == True und die Kategorien sind gleich.
alle Vergleiche kategorialer Daten mit einem Skalar.

Schauen Sie sich das folgende Beispiel an -

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

Es ist output ist wie folgt -

0  False
1  False
2  True
dtype: bool

Grundlegende Darstellung: Darstellung

Diese Funktionalität für Series und DataFrame ist nur ein einfacher Wrapper um die matplotlib libraries plot() Methode.

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

Es ist output ist wie folgt -

Wenn der Index aus Datumsangaben besteht, wird aufgerufen gct().autofmt_xdate() um die x-Achse wie in der obigen Abbildung gezeigt zu formatieren.

Wir können eine Spalte gegen eine andere mit dem zeichnen x und y Schlüsselwörter.

Plotmethoden ermöglichen eine Handvoll anderer Plotstile als das Standardliniendiagramm. Diese Methoden können als Schlüsselwortargument für angegeben werdenplot(). Dazu gehören -

Bar oder Barh für Bar-Parzellen
hist für Histogramm
Box für Boxplot
'Fläche' für Flächengrundstücke
'Streuung' für Streudiagramme

Bar Plot

Lassen Sie uns nun sehen, was ein Balkendiagramm ist, indem wir eines erstellen. Ein Balkendiagramm kann folgendermaßen erstellt werden:

import pandas as pd
import numpy as np

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

Es ist output ist wie folgt -

Um ein gestapeltes Balkendiagramm zu erstellen, 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)

Es ist output ist wie folgt -

Verwenden Sie die, um horizontale Balkendiagramme zu erhalten barh Methode -

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)

Es ist output ist wie folgt -

Histogramme

Histogramme können mit der erstellt werden plot.hist()Methode. Wir können die Anzahl der Fächer angeben.

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)

Es ist output ist wie folgt -

Verwenden Sie den folgenden Code, um unterschiedliche Histogramme für jede Spalte zu zeichnen:

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)

Es ist output ist wie folgt -

Box Plots

Boxplot kann telefonisch gezeichnet werden Series.box.plot() und DataFrame.box.plot(), oder DataFrame.boxplot() um die Verteilung der Werte innerhalb jeder Spalte zu visualisieren.

Hier ist zum Beispiel ein Boxplot, der fünf Versuche mit 10 Beobachtungen einer einheitlichen Zufallsvariablen auf [0,1] darstellt.

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

Es ist output ist wie folgt -

Flächengrundstück

Flächendiagramm kann mit dem erstellt werden Series.plot.area() oder der DataFrame.plot.area() Methoden.

import pandas as pd
import numpy as np

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

Es ist output ist wie folgt -

Streudiagramm

Ein Streudiagramm kann mit dem erstellt werden DataFrame.plot.scatter() Methoden.

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

Es ist output ist wie folgt -

Kuchendiagramm

Kreisdiagramm kann mit dem erstellt werden DataFrame.plot.pie() Methode.

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)

Es ist output ist wie folgt -

Das Pandas I/O API ist eine Reihe von Top-Level-Reader-Funktionen, auf die wie zugegriffen wird pd.read_csv() das gibt im Allgemeinen ein Pandas-Objekt zurück.

Die beiden Arbeitstierfunktionen zum Lesen von Textdateien (oder Flatfiles) sind read_csv() und read_table(). Beide verwenden denselben Parsing-Code, um Tabellendaten intelligent in a zu konvertierenDataFrame Objekt -

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

Hier ist wie die csv Dateidaten sehen aus wie -

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

Speichern Sie diese Daten als temp.csv und Operationen darauf durchführen.

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

Speichern Sie diese Daten als temp.csv und Operationen darauf durchführen.

read.csv

read.csv Liest Daten aus den CSV-Dateien und erstellt ein DataFrame-Objekt.

import pandas as pd

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

Es ist output ist wie folgt -

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

benutzerdefinierter Index

Dies gibt eine Spalte in der CSV-Datei an, mit der der Index angepasst werden soll index_col.

import pandas as pd

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

Es ist output ist wie folgt -

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

Konverter

dtype der Spalten kann als Diktat übergeben werden.

import pandas as pd

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

Es ist output ist wie folgt -

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

Standardmäßig ist die dtype der Gehaltsspalte ist int, aber das Ergebnis zeigt es als float weil wir den Typ explizit gegossen haben.

Somit sehen die Daten wie float aus -

S.No   Name   Age      City    Salary
0   1     Tom   28    Toronto   20000.0
1   2     Lee   32   HongKong    3000.0
2   3  Steven   43   Bay Area    8300.0
3   4     Ram   38  Hyderabad    3900.0

header_names

Geben Sie die Namen des Headers mit dem Argument names an.

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

Es ist output ist wie folgt -

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

Beachten Sie, dass die Headernamen an die benutzerdefinierten Namen angehängt werden, der Header in der Datei jedoch nicht entfernt wurde. Jetzt verwenden wir das Header-Argument, um das zu entfernen.

Wenn sich die Kopfzeile in einer anderen als der ersten Zeile befindet, übergeben Sie die Zeilennummer an die Kopfzeile. Dadurch werden die vorhergehenden Zeilen übersprungen.

import pandas as pd 

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

Es ist output ist wie folgt -

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 überspringt die Anzahl der angegebenen Zeilen.

import pandas as pd

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

Es ist output ist wie folgt -

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

Sparse-Objekte werden „komprimiert“, wenn Daten, die einem bestimmten Wert entsprechen (NaN / fehlender Wert, obwohl ein beliebiger Wert ausgewählt werden kann), weggelassen werden. Ein spezielles SparseIndex-Objekt verfolgt, wo Daten "sparsifiziert" wurden. Dies ist in einem Beispiel viel sinnvoller. Alle Standard-Pandas-Datenstrukturen gelten fürto_sparse Methode -

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

Es ist output ist wie folgt -

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)

Die spärlichen Objekte existieren aus Gründen der Speichereffizienz.

Nehmen wir nun an, Sie hatten einen großen NA-Datenrahmen und führen den folgenden Code aus:

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

Es ist output ist wie folgt -

0.0001

Jedes spärliche Objekt kann durch Aufrufen wieder in die Standardform mit hoher Dichte konvertiert werden 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()

Es ist output ist wie folgt -

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

Spärliche D-Typen

Sparse-Daten sollten den gleichen Typ wie ihre dichte Darstellung haben. Zur Zeit,float64, int64 und booldtypessind unterstützt. Abhängig vom Originaldtype, fill_value default Änderungen -

float64 - np.nan
int64 - 0
bool - Falsch

Lassen Sie uns den folgenden Code ausführen, um dasselbe zu verstehen:

import pandas as pd
import numpy as np

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

s.to_sparse()
print s

Es ist output ist wie folgt -

0   1.0
1   NaN
2   NaN
dtype: float64

0   1.0
1   NaN
2   NaN
dtype: float64

Vorsichtsmaßnahmen bedeuten Warnung und Gotcha bedeutet ein unsichtbares Problem.

Verwenden der If / Truth-Anweisung mit Pandas

Pandas folgt der Numpy-Konvention, einen Fehler auszulösen, wenn Sie versuchen, etwas in a umzuwandeln bool. Dies geschieht in einemif oder when Verwenden der Booleschen Operationen und or, oder not. Es ist nicht klar, was das Ergebnis sein soll. Sollte es wahr sein, weil es keine Nulllänge ist? Falsch, weil es falsche Werte gibt? Es ist unklar, also erhöht Pandas stattdessen aValueError - -

import pandas as pd

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

Es ist output ist wie folgt -

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

Im ifBedingung ist es unklar, was damit zu tun ist. Der Fehler deutet darauf hin, ob a verwendet werden sollNone oder any of those.

import pandas as pd

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

Es ist output ist wie folgt -

I am any

Verwenden Sie die Methode, um Pandas-Objekte mit einem Element in einem booleschen Kontext auszuwerten .bool() - -

import pandas as pd

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

Es ist output ist wie folgt -

True

Bitweiser Boolescher Wert

Bitweise Boolesche Operatoren wie == und != gibt eine Boolesche Reihe zurück, was sowieso fast immer erforderlich ist.

import pandas as pd

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

Es ist output ist wie folgt -

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

ist im Betrieb

Dies gibt eine boolesche Reihe zurück, die zeigt, ob jedes Element in der Reihe genau in der übergebenen Wertesequenz enthalten ist.

import pandas as pd

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

Es ist output ist wie folgt -

0 True
1 False
2 True
dtype: bool

Neuindizierung gegen ix Gotcha

Viele Benutzer werden feststellen, dass sie das verwenden ix indexing capabilities als prägnantes Mittel zur Auswahl von Daten aus einem Pandas-Objekt -

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

Es ist output ist wie folgt -

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

Dies ist in diesem Fall natürlich völlig gleichbedeutend mit der Verwendung von reindex Methode -

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

Es ist output ist wie folgt -

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

Einige könnten daraus schließen ix und reindexsind basierend darauf 100% äquivalent. Dies gilt nur für die Ganzzahlindizierung. Zum Beispiel kann die obige Operation alternativ ausgedrückt werden als -

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

Es ist output ist wie folgt -

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

Es ist wichtig, sich daran zu erinnern reindex is strict label indexing only. Dies kann zu einigen möglicherweise überraschenden Ergebnissen in pathologischen Fällen führen, in denen ein Index beispielsweise sowohl Ganzzahlen als auch Zeichenfolgen enthält.

Da viele potenzielle Pandas-Benutzer mit SQL vertraut sind, soll diese Seite einige Beispiele dafür enthalten, wie verschiedene SQL-Vorgänge mit Pandas ausgeführt werden können.

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

Es ist output ist wie folgt -

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

WÄHLEN

In SQL erfolgt die Auswahl mithilfe einer durch Kommas getrennten Liste der von Ihnen ausgewählten Spalten (oder eines *, um alle Spalten auszuwählen).

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

Bei Pandas erfolgt die Spaltenauswahl durch Übergeben einer Liste von Spaltennamen an Ihren DataFrame.

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

Lassen Sie uns das vollständige Programm überprüfen -

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)

Es ist output ist wie folgt -

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

Wenn Sie den DataFrame ohne die Liste der Spaltennamen aufrufen, werden alle Spalten angezeigt (ähnlich wie bei SQL *).

WO

Das Filtern in SQL erfolgt über eine WHERE-Klausel.

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

DataFrames können auf verschiedene Arten gefiltert werden. Am intuitivsten ist die Verwendung der Booleschen Indizierung.

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

Lassen Sie uns das vollständige Programm überprüfen -

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)

Es ist output ist wie folgt -

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

Die obige Anweisung übergibt eine Reihe von True / False-Objekten an den DataFrame und gibt alle Zeilen mit True zurück.

Gruppiere nach

Diese Operation ruft die Anzahl der Datensätze in jeder Gruppe in einem Datensatz ab. Zum Beispiel eine Abfrage, die uns die Anzahl der Tipps abruft, die das Geschlecht hinterlassen hat -

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

Das Pandas-Äquivalent wäre -

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

Lassen Sie uns das vollständige Programm überprüfen -

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

Es ist output ist wie folgt -

sex
Female   87
Male    157
dtype: int64

Top N Reihen

SQL gibt das zurück top n rows mit LIMIT - -

SELECT * FROM tips
LIMIT 5 ;

Das Pandas-Äquivalent wäre -

tips.head(5)

Schauen wir uns das vollständige Beispiel an -

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

Es ist output ist wie folgt -

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

Dies sind die wenigen grundlegenden Operationen, die wir in den vorherigen Kapiteln der Pandas-Bibliothek verglichen haben.