Apprenez-vous les opérations sympas des pandas que 1 % des gens connaissent

La colonne

tutoriel python présente le fonctionnement des pandas aujourd'hui.

pandas a une méthode très puissante, qui est accessor, qui peut être comprise comme une interface de propriété à travers laquelle des méthodes supplémentaires peuvent être obtenues. En fait, cela reste très général. Comprenons-le à travers du code et des exemples.

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

En utilisant la méthode _accessors pour la structure de données Series, nous obtenons 3 objets : cat, str, dt.

• .cat : est utilisé pour les données catégorielles (Données catégoriques)
• .str : est utilisé pour les données de caractères (Objet chaîne data)
• .dt : Utilisé pour les données temporelles (données de type datetime)

Voyons comment ces trois objets sont utilisés tour à tour.

Utilisation de l'objet str

Type de données série : 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复制代码

Explication des deux méthodes de l'objet str ci-dessus :

• Series.str.upper : modifie toutes les chaînes de la série en majuscules
• Series.str.count : modifie tous les caractères de la série ; nombre de chaînes ;

En fait, il n'est pas difficile de constater que l'utilisation de cet usage est très similaire au fonctionnement des chaînes en Python. Oui, vous pouvez effectuer des opérations aussi simples dans les pandas, mais la différence est que vous exploitez une colonne entière de données de chaîne. Toujours sur la base de l'ensemble de données ci-dessus, regardons une autre opération :

>>> 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复制代码

Description des deux méthodes de l'objet str ci-dessus :

• Series.str.replace : Remplacer la chaîne spécifiée dans la série ;
• Series.str.extract : Extraire les informations de données dans la chaîne via des expressions régulières

Ceci ; L'utilisation est un peu compliquée, car il est évident qu'il s'agit d'une utilisation en chaîne. Utilisez replace pour remplacer "." par "", qui est vide puis utilise 3 expressions régulières (correspondant respectivement à la ville, à l'état, au zip) pour extraire les données, et modifiées. de la structure de données Series d'origine à la structure de données DataFrame.

Bien sûr, en plus de l'utilisation ci-dessus, les attributs et méthodes couramment utilisés incluent .rstrip, .contains, split, etc. Vérifions l'attribut str via le code suivant Liste complète :

>>> [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']复制代码

Il existe de nombreux attributs Pour un usage spécifique, si vous êtes intéressé, vous pouvez explorer et pratiquer par vous-même.

Utilisation de l'objet dt

Type de données série : datetime

Étant donné que les données nécessitent le type datetime, ce qui suit utilise date_range() de pandas pour générer un groupe date datetime montre comment effectuer des opérations sur les objets dt.

>>> 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]复制代码

Les trois méthodes de dt ci-dessus sont expliquées :

• Series.dt.day_name() : Juger le jour de la semaine à partir de la date ; 🎜>
• Series.dt. quarter : Déterminez la saison à partir de la date
• Series.dt.is_year_end : Déterminez si c'est la fin du ; année à partir de la date ;

D'autres méthodes sont également basées sur certaines transformations de datetime et utilisent des transformations pour afficher des dates micro ou macro spécifiques.

Utilisation de l'objet cat

Type de données série : Catégorie

Avant de parler de l'utilisation de l'objet cat, parlons du type de données Catégorie. L'effet est très puissant. Bien que nous n'exécutions pas fréquemment des données g en mémoire, nous rencontrons toujours des situations dans lesquelles l'exécution de quelques lignes de code attendra longtemps. L'un des avantages de l'utilisation des données de catégorie est que

permet de gagner du temps et de l'espace. Apprenons à travers plusieurs exemples.

>>> 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复制代码

Ci-dessus, nous utilisons

sys.getsizeof pour afficher l'utilisation de la mémoire, et le nombre représente le nombre d'octets. Il existe une autre façon de calculer l'utilisation du contenu :
memory_usage(), qui sera utilisée plus tard.

Maintenant, nous mappons les valeurs uniques des couleurs ci-dessus à un ensemble d'entiers, puis examinons la mémoire occupée.

>>> 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复制代码

Remarque : pour le mappage de valeurs entières ci-dessus, vous pouvez également utiliser la méthode plus simple

pd.factorize() à la place.

Nous avons constaté que la mémoire occupée ci-dessus est la moitié de celle utilisée pour l'utilisation du type d'objet. En fait, cette situation est similaire au principe interne du type de données Catégorie.

Différence d'utilisation de la mémoire : La mémoire occupée par Catégorique est proportionnelle au nombre de catégories Catégorielles et à la longueur des données. Au contraire, la mémoire occupée par l'objet est. une constante multipliée par la longueur des données.

Ce qui suit est une comparaison de l'utilisation de la mémoire des objets et de l'utilisation de la mémoire des catégories.

>>> 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教程（视频）

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!