Bringen Sie Ihnen die coolen Pandas-Operationen bei, die 1 % der Menschen kennt

Die Kolumne

Python-Tutorial stellt heute die Funktionsweise von Pandas vor.

pandas verfügt über eine sehr leistungsstarke Methode, nämlich accessor, die als Eigenschaftsschnittstelle verstanden werden kann, über die zusätzliche Methoden abgerufen werden können. Tatsächlich ist dies immer noch sehr allgemein. Lassen Sie es uns anhand von Code und Beispielen verstehen.

>>> pd.Series._accessors
{'cat', 'str', 'dt'}复制代码

Mit der _accessors-Methode für die Datenstruktur Series erhalten wir 3 Objekte: cat, str, dt.

• .cat: für kategoriale Daten
• .str: für Zeichendaten (String-Objektdaten)
• .dt: für datetime-ähnliche Daten

Schauen wir uns an, wie diese drei Objekte funktionieren werden der Reihe nach verwendet.

Verwendung des Str-Objekts

Seriendatentyp: Str-String

# 定义一个Series序列
>>> addr = pd.Series([
...     'Washington, D.C. 20003',
...     'Brooklyn, NY 11211-1755',
...     'Omaha, NE 68154',
...     'Pittsburgh, PA 15211'
... ]) 

>>> addr.str.upper()
0     WASHINGTON, D.C. 20003
1    BROOKLYN, NY 11211-1755
2            OMAHA, NE 68154
3       PITTSBURGH, PA 15211
dtype: object

>>> addr.str.count(r'\d') 
0    5
1    9
2    5
3    5
dtype: int64复制代码

Über die beiden Methoden des obigen Str-Objekts:

• Series.str.upper: Ändern Sie alle Zeichenfolgen in Serie in Großbuchstaben ;
• Series.str.count: Zählt die Anzahl aller Strings in der Serie

Tatsächlich ist es nicht schwer festzustellen, dass die Verwendung dieser Verwendung der Operation von Strings in Python sehr ähnlich ist. Ja, Sie können solche einfachen Operationen in Pandas ausführen, aber der Unterschied besteht darin, dass Sie eine ganze Spalte mit Zeichenfolgendaten bearbeiten. Schauen wir uns immer noch basierend auf dem obigen Datensatz eine weitere Operation an:

>>> regex = (r&#39;(?P<city>[A-Za-z ]+), &#39;      # 一个或更多字母
...          r&#39;(?P<state>[A-Z]{2}) &#39;        # 两个大写字母
...          r&#39;(?P<zip>\d{5}(?:-\d{4})?)&#39;)  # 可选的4个延伸数字
...
>>> addr.str.replace(&#39;.&#39;, &#39;&#39;).str.extract(regex)
         city state         zip
0  Washington    DC       20003
1    Brooklyn    NY  11211-1755
2       Omaha    NE       68154
3  Pittsburgh    PA       15211复制代码

Beschreibung der beiden Methoden des obigen str-Objekts:

• Series.str.replace: Ersetzen Sie die angegebene Zeichenfolge in Series;
• Series .str.extract: Extrahieren Sie die Dateninformationen in der Zeichenfolge durch reguläre Ausdrücke.

Diese Verwendung ist etwas kompliziert, da es sich offensichtlich um eine Kettenverwendung handelt. Ersetzen Sie „.“ durch „“ durch replace, was leer ist Dann verwenden wir 3 reguläre Ausdrücke (entsprechend Stadt, Bundesland bzw. Postleitzahl), um die Daten durch Extrahieren zu extrahieren, und verwenden die ursprüngliche Datenstruktur der Serie eine DataFrame-Datenstruktur.

Zu den häufig verwendeten Attributen und Methoden gehören neben der oben genannten Verwendung natürlich auch .rstrip, .contains, split usw. Sehen wir uns die vollständige Liste der str-Attribute mit dem folgenden Code an:

>>> [i for i in dir(pd.Series.str) if not i.startswith('_')]
['capitalize',
 'cat',
 'center',
 'contains',
 'count',
 'decode',
 'encode',
 'endswith',
 'extract',
 'extractall',
 'find',
 'findall',
 'get',
 'get_dummies',
 'index',
 'isalnum',
 'isalpha',
 'isdecimal',
 'isdigit',
 'islower',
 'isnumeric',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'len',
 'ljust',
 'lower',
 'lstrip',
 'match',
 'normalize',
 'pad',
 'partition',
 'repeat',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'slice',
 'slice_replace',
 'split',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'wrap',
 'zfill']复制代码

Es gibt viele Attribute, für spezifische Wenn Sie daran interessiert sind, es zu verwenden, können Sie es selbst erkunden und üben.

Verwendung von dt-Objekten

Seriendatentyp: datetime

Da die Daten den Typ datetime erfordern, wird im Folgenden date_range() von pandas verwendet, um eine Reihe von Datumsangaben datetime zu generieren und zu demonstrieren, wie dt-Objektoperationen ausgeführt werden.

>>> daterng = pd.Series(pd.date_range('2017', periods=9, freq='Q'))
>>> daterng
0   2017-03-31
1   2017-06-30
2   2017-09-30
3   2017-12-31
4   2018-03-31
5   2018-06-30
6   2018-09-30
7   2018-12-31
8   2019-03-31
dtype: datetime64[ns]

>>>  daterng.dt.day_name()
0      Friday
1      Friday
2    Saturday
3      Sunday
4    Saturday
5    Saturday
6      Sunday
7      Monday
8      Sunday
dtype: object

>>> # 查看下半年
>>> daterng[daterng.dt.quarter > 2]
2   2017-09-30
3   2017-12-31
6   2018-09-30
7   2018-12-31
dtype: datetime64[ns]

>>> daterng[daterng.dt.is_year_end]
3   2017-12-31
7   2018-12-31
dtype: datetime64[ns]复制代码

Die oben genannten drei Methoden zu dt:

• Series.dt.day_name(): Beurteilen Sie die Anzahl der Wochen ab dem Datum;
• Series.dt.quarter: Beurteilen Sie die Saison anhand des Datums;
• Series.dt.is_year_end: Beurteilen Sie anhand des Datums, ob es das Ende des Jahres ist.

Andere Methoden basieren ebenfalls auf einigen Datums- und Uhrzeittransformationen und verwenden Transformationen, um bestimmte Mikro- oder Makrodaten anzuzeigen.

Verwendung des Katzenobjekts

Seriendatentyp: Kategorie

Bevor wir über die Verwendung des Katzenobjekts sprechen, sprechen wir über den Kategoriedatentyp, der sehr leistungsfähig ist. Obwohl wir G-Daten nicht häufig im Speicher ausführen, kommt es immer wieder zu Situationen, in denen die Ausführung einiger Codezeilen lange auf sich warten lässt. Ein Vorteil der Verwendung von Kategoriedaten besteht darin, dass dadurch Zeit und Platz gespart werden können. Lassen Sie es uns anhand mehrerer Beispiele lernen.

>>> colors = pd.Series([
...     'periwinkle',
...     'mint green',
...     'burnt orange',
...     'periwinkle',
...     'burnt orange',
...     'rose',
...     'rose',
...     'mint green',
...     'rose',
...     'navy'
... ])
...
>>> import sys
>>> colors.apply(sys.getsizeof)
0    59
1    59
2    61
3    59
4    61
5    53
6    53
7    59
8    53
9    53
dtype: int64复制代码

Oben haben wir

sys.getsizeof verwendet, um die Speichernutzung anzuzeigen, und die Zahl stellt die Anzahl der Bytes dar. Es gibt eine andere Möglichkeit, die Inhaltsnutzung zu berechnen:
memory_usage(), die später verwendet wird.

Jetzt ordnen wir die eindeutigen Werte der oben genannten Farben einer Reihe von Ganzzahlen zu und werfen dann einen Blick auf den belegten Speicher.

>>> mapper = {v: k for k, v in enumerate(colors.unique())}
>>> mapper
{'periwinkle': 0, 'mint green': 1, 'burnt orange': 2, 'rose': 3, 'navy': 4}

>>> as_int = colors.map(mapper)
>>> as_int
0    0
1    1
2    2
3    0
4    2
5    3
6    3
7    1
8    3
9    4
dtype: int64

>>> as_int.apply(sys.getsizeof)
0    24
1    28
2    28
3    24
4    28
5    28
6    28
7    28
8    28
9    28
dtype: int64复制代码

Hinweis: Für die obige Ganzzahlwertzuordnung können Sie stattdessen auch die einfachere Methode

pd.factorize() verwenden.

Wir haben festgestellt, dass der oben belegte Speicher halb so groß ist wie bei Verwendung des Objekttyps. Tatsächlich ähnelt diese Situation dem internen Prinzip des Kategoriedatentyps.

Unterschied in der Speichernutzung: Der von Categorical belegte Speicher ist proportional zur Anzahl der kategorialen Kategorien und der Länge der Daten. Im Gegenteil, der vom Objekt belegte Speicher ist eine Konstante multipliziert mit der Länge der Daten.

Das Folgende ist ein Vergleich der Objektspeichernutzung und der Kategoriespeichernutzung.

>>> colors.memory_usage(index=False, deep=True)
650
>>> colors.astype('category').memory_usage(index=False, deep=True)
495复制代码

上面结果是使用object和Category两种情况下内存的占用情况。我们发现效果并没有我们想象中的那么好。但是注意Category内存是成比例的，如果数据集的数据量很大，但不重复分类（unique）值很少的情况下，那么Category的内存占用可以节省达到10倍以上，比如下面数据量增大的情况：

>>> manycolors = colors.repeat(10)
>>> len(manycolors) / manycolors.nunique() 
20.0

>>> manycolors.memory_usage(index=False, deep=True)
6500
>>> manycolors.astype('category').memory_usage(index=False, deep=True)
585复制代码

可以看到，在数据量增加10倍以后，使用Category所占内容节省了10倍以上。

除了占用内存节省外，另一个额外的好处是计算效率有了很大的提升。因为对于Category类型的Series，str字符的操作发生在.cat.categories的非重复值上，而并非原Series上的所有元素上。也就是说对于每个非重复值都只做一次操作，然后再向与非重复值同类的值映射过去。

对于Category的数据类型，可以使用accessor的cat对象，以及相应的属性和方法来操作Category数据。

>>> ccolors = colors.astype('category')
>>> ccolors.cat.categories
Index(['burnt orange', 'mint green', 'navy', 'periwinkle', 'rose'], dtype='object')复制代码

实际上，对于开始的整数类型映射，我们可以先通过reorder_categories进行重新排序，然后再使用cat.codes来实现对整数的映射，来达到同样的效果。

>>> ccolors.cat.reorder_categories(mapper).cat.codes
0    0
1    1
2    2
3    0
4    2
5    3
6    3
7    1
8    3
9    4
dtype: int8复制代码

dtype类型是Numpy的int8（-127~128）。可以看出以上只需要一个单字节就可以在内存中包含所有的值。我们开始的做法默认使用了int64类型，然而通过pandas的使用可以很智能的将Category数据类型变为最小的类型。

让我们来看一下cat还有什么其它的属性和方法可以使用。下面cat的这些属性基本都是关于查看和操作Category数据类型的。

>>> [i for i in dir(ccolors.cat) if not i.startswith('_')]
['add_categories',
 'as_ordered',
 'as_unordered',
 'categories',
 'codes',
 'ordered',
 'remove_categories',
 'remove_unused_categories',
 'rename_categories',
 'reorder_categories',
 'set_categories']复制代码

但是Category数据的使用不是很灵活。例如，插入一个之前没有的值，首先需要将这个值添加到.categories的容器中，然后再添加值。

>>> ccolors.iloc[5] = 'a new color'
# ...
ValueError: Cannot setitem on a Categorical with a new category,
set the categories first

>>> ccolors = ccolors.cat.add_categories(['a new color'])
>>> ccolors.iloc[5] = 'a new color'  
复制代码

如果你想设置值或重塑数据，而非进行新的运算操作，那么Category类型不是那么有用。

相关免费学习推荐：python教程（视频）

Das obige ist der detaillierte Inhalt vonBringen Sie Ihnen die coolen Pandas-Operationen bei, die 1 % der Menschen kennt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!