Меню

Pandas как найти подстроку в строке

Working with text data#

Text data types#

There are two ways to store text data in pandas:

We recommend using StringDtype to store text data.

Prior to pandas 1.0, object dtype was the only option. This was unfortunate for many reasons:

You can accidentally store a mixture of strings and non-strings in an object dtype array. It’s better to have a dedicated dtype.

object dtype breaks dtype-specific operations like DataFrame.select_dtypes() . There isn’t a clear way to select just text while excluding non-text but still object-dtype columns.

When reading code, the contents of an object dtype array is less clear than ‘string’ .

Currently, the performance of object dtype arrays of strings and arrays.StringArray are about the same. We expect future enhancements to significantly increase the performance and lower the memory overhead of StringArray .

StringArray is currently considered experimental. The implementation and parts of the API may change without warning.

For backwards-compatibility, object dtype remains the default type we infer a list of strings to

To explicitly request string dtype, specify the dtype

Or astype after the Series or DataFrame is created

You can also use StringDtype / «string» as the dtype on non-string data and it will be converted to string dtype:

or convert from existing pandas data:

Behavior differences#

These are places where the behavior of StringDtype objects differ from object dtype

For StringDtype , string accessor methods that return numeric output will always return a nullable integer dtype, rather than either int or float dtype, depending on the presence of NA values. Methods returning boolean output will return a nullable boolean dtype.

Both outputs are Int64 dtype. Compare that with object-dtype

When NA values are present, the output dtype is float64. Similarly for methods returning boolean values.

Some string methods, like Series.str.decode() are not available on StringArray because StringArray only holds strings, not bytes.

In comparison operations, arrays.StringArray and Series backed by a StringArray will return an object with BooleanDtype , rather than a bool dtype object. Missing values in a StringArray will propagate in comparison operations, rather than always comparing unequal like numpy.nan .

Everything else that follows in the rest of this document applies equally to string and object dtype.

String methods#

Series and Index are equipped with a set of string processing methods that make it easy to operate on each element of the array. Perhaps most importantly, these methods exclude missing/NA values automatically. These are accessed via the str attribute and generally have names matching the equivalent (scalar) built-in string methods:

The string methods on Index are especially useful for cleaning up or transforming DataFrame columns. For instance, you may have columns with leading or trailing whitespace:

Since df.columns is an Index object, we can use the .str accessor

These string methods can then be used to clean up the columns as needed. Here we are removing leading and trailing whitespaces, lower casing all names, and replacing any remaining whitespaces with underscores:

If you have a Series where lots of elements are repeated (i.e. the number of unique elements in the Series is a lot smaller than the length of the Series ), it can be faster to convert the original Series to one of type category and then use .str. or .dt.

on that. The performance difference comes from the fact that, for Series of type category , the string operations are done on the .categories and not on each element of the Series .

Please note that a Series of type category with string .categories has some limitations in comparison to Series of type string (e.g. you can’t add strings to each other: s + » » + s won’t work if s is a Series of type category ). Also, .str methods which operate on elements of type list are not available on such a Series .

Before v.0.25.0, the .str -accessor did only the most rudimentary type checks. Starting with v.0.25.0, the type of the Series is inferred and the allowed types (i.e. strings) are enforced more rigorously.

Generally speaking, the .str accessor is intended to work only on strings. With very few exceptions, other uses are not supported, and may be disabled at a later point.

Splitting and replacing strings#

Methods like split return a Series of lists:

Elements in the split lists can be accessed using get or [] notation:

It is easy to expand this to return a DataFrame using expand .

When original Series has StringDtype , the output columns will all be StringDtype as well.

It is also possible to limit the number of splits:

rsplit is similar to split except it works in the reverse direction, i.e., from the end of the string to the beginning of the string:

Some caution must be taken when dealing with regular expressions! The current behavior is to treat single character patterns as literal strings, even when regex is set to True . This behavior is deprecated and will be removed in a future version so that the regex keyword is always respected.

If you want literal replacement of a string (equivalent to str.replace() ), you can set the optional regex parameter to False , rather than escaping each character. In this case both pat and repl must be strings:

The replace method can also take a callable as replacement. It is called on every pat using re.sub() . The callable should expect one positional argument (a regex object) and return a string.

The replace method also accepts a compiled regular expression object from re.compile() as a pattern. All flags should be included in the compiled regular expression object.

Including a flags argument when calling replace with a compiled regular expression object will raise a ValueError .

removeprefix and removesuffix have the same effect as str.removeprefix and str.removesuffix added in Python 3.9 `__:

Concatenation#

There are several ways to concatenate a Series or Index , either with itself or others, all based on cat() , resp. Index.str.cat .

Concatenating a single Series into a string#

The content of a Series (or Index ) can be concatenated:

If not specified, the keyword sep for the separator defaults to the empty string, sep=» :

By default, missing values are ignored. Using na_rep , they can be given a representation:

Concatenating a Series and something list-like into a Series#

The first argument to cat() can be a list-like object, provided that it matches the length of the calling Series (or Index ).

Missing values on either side will result in missing values in the result as well, unless na_rep is specified:

Concatenating a Series and something array-like into a Series#

The parameter others can also be two-dimensional. In this case, the number or rows must match the lengths of the calling Series (or Index ).

Concatenating a Series and an indexed object into a Series, with alignment#

For concatenation with a Series or DataFrame , it is possible to align the indexes before concatenation by setting the join -keyword.

If the join keyword is not passed, the method cat() will currently fall back to the behavior before version 0.23.0 (i.e. no alignment), but a FutureWarning will be raised if any of the involved indexes differ, since this default will change to join=’left’ in a future version.

The usual options are available for join (one of ‘left’, ‘outer’, ‘inner’, ‘right’ ). In particular, alignment also means that the different lengths do not need to coincide anymore.

The same alignment can be used when others is a DataFrame :

Concatenating a Series and many objects into a Series#

Several array-like items (specifically: Series , Index , and 1-dimensional variants of np.ndarray ) can be combined in a list-like container (including iterators, dict -views, etc.).

All elements without an index (e.g. np.ndarray ) within the passed list-like must match in length to the calling Series (or Index ), but Series and Index may have arbitrary length (as long as alignment is not disabled with join=None ):

If using join=’right’ on a list-like of others that contains different indexes, the union of these indexes will be used as the basis for the final concatenation:

Indexing with .str #

You can use [] notation to directly index by position locations. If you index past the end of the string, the result will be a NaN .

Extracting substrings#

Extract first match in each subject (extract)#

Before version 0.23, argument expand of the extract method defaulted to False . When expand=False , expand returns a Series , Index , or DataFrame , depending on the subject and regular expression pattern. When expand=True , it always returns a DataFrame , which is more consistent and less confusing from the perspective of a user. expand=True has been the default since version 0.23.0.

The extract method accepts a regular expression with at least one capture group.

Extracting a regular expression with more than one group returns a DataFrame with one column per group.

Elements that do not match return a row filled with NaN . Thus, a Series of messy strings can be “converted” into a like-indexed Series or DataFrame of cleaned-up or more useful strings, without necessitating get() to access tuples or re.match objects. The dtype of the result is always object, even if no match is found and the result only contains NaN .

can also be used. Note that any capture group names in the regular expression will be used for column names; otherwise capture group numbers will be used.

Extracting a regular expression with one group returns a DataFrame with one column if expand=True .

It returns a Series if expand=False .

Calling on an Index with a regex with exactly one capture group returns a DataFrame with one column if expand=True .

It returns an Index if expand=False .

Calling on an Index with a regex with more than one capture group returns a DataFrame if expand=True .

It raises ValueError if expand=False .

The table below summarizes the behavior of extract(expand=False) (input subject in first column, number of groups in regex in first row)

Extract all matches in each subject (extractall)#

Unlike extract (which returns only the first match),

the extractall method returns every match. The result of extractall is always a DataFrame with a MultiIndex on its rows. The last level of the MultiIndex is named match and indicates the order in the subject.

When each subject string in the Series has exactly one match,

then extractall(pat).xs(0, level=’match’) gives the same result as extract(pat) .

Index also supports .str.extractall . It returns a DataFrame which has the same result as a Series.str.extractall with a default index (starts from 0).

Testing for strings that match or contain a pattern#

You can check whether elements contain a pattern:

Or whether elements match a pattern:

The distinction between match , fullmatch , and contains is strictness: fullmatch tests whether the entire string matches the regular expression; match tests whether there is a match of the regular expression that begins at the first character of the string; and contains tests whether there is a match of the regular expression at any position within the string.

The corresponding functions in the re package for these three match modes are re.fullmatch, re.match, and re.search, respectively.

Methods like match , fullmatch , contains , startswith , and endswith take an extra na argument so missing values can be considered True or False:

Creating indicator variables#

You can extract dummy variables from string columns. For example if they are separated by a ‘|’ :

String Index also supports get_dummies which returns a MultiIndex .

Источник статьи: http://pandas.pydata.org/pandas-docs/stable/user_guide/text.html

Pandas – Search for String in DataFrame Column

In this tutorial, we will look at how to search for a string (or a substring) in a pandas dataframe column with the help of some examples.

How to check if a pandas series contains a string?

You can use the pandas.series.str.contains() function to search for the presence of a string in a pandas series (or column of a dataframe). You can also pass a regex to check for more custom patterns in the series values. The following is the syntax:

It returns a boolean Series or Index based on whether a given pattern or regex is contained within a string of a Series or Index.

The case parameter tells whether to match the string in a case-sensitive manner or not.

The regex parameter tells the function that you want to match for a specific regex pattern.

The flags parameter can be used to pass additional flags for the regex match through to the re module (for example re.IGNORECASE )

Let’s look at some examples to see the above syntax in action

Search for string in pandas column or series

Pass the string you want to check for as an argument.

Here, we created a pandas series containing names of some India’s top cricketers. We then find the names containing the word “Singh” using the str.contains() function. We also pass regex=False to indicate not to assume the passed value as a regex pattern. In this case, you can also go with the default regex=True as it would not make any difference.

Also note that we get the result as a pandas series of boolean values representing which of the values contained the given string. You can use this series to filter values in the original series.

For example, let’s only print out the names containing the word “Singh”

Here we applied the .str.contains() function on a pandas series. Note that you can also apply it on individual columns of a pandas dataframe.

Search for string irrespective of case

By default, the pd.series.str.contains() function’s string searches are case sensitive.

We get False for “yuvraj singh” because it does not contain the word “Singh” in the same case.

You can, however make the function search for strings irrespective of the case by passing False to the case parameter.

Search for a matching regex pattern in column

You can also pass regex patterns to the above function for searching more complex values/patterns in the series.

Here we created a pandas series with values representing different outcomes when a blower bowls a ball in cricket. Let’s say we want to find all the good balls which can be defined as either a wicket or a dot ball. We used the regex pattern ‘wicket|dot ball’ to match with either “wicket” or “dot ball”.

You can similarly write more complex regex patterns depending on your use-case to match values in a pandas series.

For more the pd.Series.str.contains() function, refer to its documentation.

With this, we come to the end of this tutorial. The code examples and results presented in this tutorial have been implemented in a Jupyter Notebook with a python (version 3.8.3) kernel having pandas version 1.0.5

Subscribe to our newsletter for more informative guides and tutorials.
We do not spam and you can opt out any time.

Источник статьи: http://datascienceparichay.com/article/pandas-search-for-string-in-dataframe-column/

Check For a Substring in a Pandas DataFrame Column

Looking for strings to cut down your dataset for analysis and machine learning

The Pandas library is a comprehensive tool not only for crunching numbers but also for working with text data.

For many data analysis applications and machine learning exploration/pre-processing, you’ll want to either filter out or extract information from text data. To do so, Pandas offers a wide range of in-built methods that you can use to add, remove, and edit text columns in your DataFrames.

In this piece, let’s take a look specifically at searching for substrings in a DataFrame column. This may come in handy when you need to create a new category based on existing data (for example during feature engineering before training a machine learning model).

If you want to follow along, download the dataset here.

NOTE: we’ll be using a lot of loc in this piece, so if you’re unfamiliar with that method, check out the first article linked at the very bottom of this piece.

Using “contains” to Find a Substring in a Pandas DataFrame

The contains method in Pandas allows you to search a column for a specific substring. The contains method returns boolean values for the Series with True for if the original Series value contains the substring and False if not. A basic application of contains should look like Series.str.contains(«substring») . However, we can immediately take this to the next level with two additions:

  1. Using the case argument to specify whether to match on string case;
  2. Using the returned Series of boolean values as a mask to get a subset of the DataFrame.

Applying these two should look like this:

Using the loc method allows us to get only the values in the DataFrame that contain the string “pokemon”. We’ve simply used the contains method to acquire True and False values based on whether the “Name” column includes our substring and then returned only the True values.

Using regex with the “contains” method in Pandas

In addition to just matching on a regular substring, we can also use contains to match on regular expressions. We’ll use the exact same format as before, except this time let’s use a bit of regex to only find the story-based Pokemon games (i.e. excluding Pokemon Pinball and the like).

Above, I just used some simple regex to find strings that matched the pattern of “pokemon” + “one character or more” + “/”. The result of the new mask returned rows including “Pokemon Red/Pokemon Blue”, “Pokemon Gold/Pokemon Silver”, and more.

Next, let’s do another quick example of using regex to find all Sports games with “football” or “soccer” in its name. First, we’ll use a simple conditional statement to filter out all rows with the a genre of “sports”:

You’ll notice that above there was no real need to match on a substring or use regex, because we were simply selecting rows based on a category. However, when matching on the row name, we’ll need to be searching different types of strings for a substring, which is where regex comes in handy. To do so, we’ll do the following:

Now we’ve gotten a DataFrame with just the games that have a name including “soccer” or “football”. We simply made use of the “|” regex “or” operator that allows you to match on a string that contains one or another substring.

So we’ve successfully gotten a DataFrame with only names that contain either “football” or “soccer”, but we don’t actually know which of those two strings it contains. If we wanted to know which of the two it contained, we could use the findall method on the name column and assign the returned values to a new column in the DataFrame.

The findall method returns matches of the pattern of regular expression you specify in each string of the Series you call it on. The format is largely the same as the contains method, except you’ll need to import re to not match on string case.

You’ll see at the end of the returned DataFrame a new column that contains either “Soccer” or “Football”, depending on which of the two the videogame name contains. This can be helpful if you need to create new columns based on the existing columns and using values from those columns.

Finally, for a quick trick to exclude strings with just one additional operator on top of the basic contains method, let’s try to get all the football and soccer games that don’t include “FIFA” in the name.

As you can see, we’ve simply made use of the

operator that allows us to take all the False values of the mask inside the loc method.

Working with strings can be a little tricky, but the in-built Pandas methods are versatile and allow you to slice and dice your data in pretty much whatever way you need. The contains and findall methods allow you to do a lot, especially when you’re able to write some regular expressions to really find specific substrings.

Источник статьи: http://towardsdatascience.com/check-for-a-substring-in-a-pandas-dataframe-column-4b949f64852

Трансформация данных в pandas ч.2 / pd 12

Манипуляция строками

Python — это популярный язык, который благодаря своей простоте часто используется для обработки строк и текста. Большая часть операций может быть выполнена даже с помощью встроенных функций. А для более сложных используются регулярные выражения.

Встроенные методы для работы со строками

В большинстве случаев имеются сложные строки, которые желательно разделять на части и присваивать их правильным переменным. Функция split() позволяет разбить тексты на части, используя разделитель в качестве ориентира. Им может быть, например, запятая.

По первому элементу видно, что в конце у него остается пробел. Чтобы решить эту проблему, вместе со split() нужно также использовать функцию strip() , которая обрезает пустое пространство (включая символы новой строки)

Результат — массив строк. Если элементов не много, то можно выполнить присваивание вот так:

Помимо разбития текста на части часто требуется сделать обратное — конкатенировать разные строки, получив в результате текст большого объема. Самый простой способ — использовать оператор + .

Но это сработает только в том случае, если строк не больше двух-трех. Если же их больше, то есть метод join() . Его нужно применять к желаемому разделителю, передав в качестве аргумента список строк.

Еще один тип операции, которую можно выполнять со строкой — поиск отдельных частей, подстрок. В Python для этого есть ключевое слово, используемое для обнаружения подстрок.

Но имеются и две функции, которые выполняют ту же задачу: index() и find() .

В обоих случаях возвращаемое значение — наименьший индекс, где встречаются искомые символы. Разница лишь в поведении функций в случае, если подстрока не была найдена:

Если index() вернет сообщение с ошибкой, то find() – -1 . Также можно посчитать, как часто символ или комбинация из нескольких (подстрока) встречаются в тексте. За это отвечает функция count() .

Еще одна доступная операция — замена или удаление подстроки (или отдельного символа). В обоих случаях применяется функция replace() , где удаление подстроки — это то же самое, что и замена ее на пустой символ.

Регулярные выражения

Регулярные выражения предоставляют гибкий способ поиска совпадающих паттернов в тексте. Выражение regex — это строка, написанная с помощью языка регулярных выражений. В Python есть встроенный модуль re, который отвечает за работу с регулярными выражениями.

В первую очередь его нужно импортировать:

Модуль re предоставляет набор функций, которые можно поделить на три категории:

  • Поиск совпадающих паттернов
  • Замена
  • Разбиение

Теперь разберем на примерах. Регулярное выражение для поиска одного или последовательности пробельных символов — \s+ . В прошлом разделе вы видели, как для разделения текста на части с помощью split() используется символ разделения. В модуле re есть такая же функция. Она выполняет аналогичную задачу, но в качестве аргумента условия разделения принимает паттерн с регулярным выражением, что делает ее более гибкой.

Разберемся чуть подробнее с принципом работы модуля re . При вызове функции re.split() сперва компилируется регулярное выражение, а только потом вызывается split() с готовым текстовым аргументом. Можно скомпилировать функцию регулярного выражения с помощью re.compile() и получить объект, который будет использоваться повторно, сэкономив таким образом циклы CPU.

Это особенно важно для операций последовательного поиска подстроки во множестве или массиве строк.

Создав объект regex с помощью функции compile() , вы сможете прямо использовать split() следующим образом.

Для поиска совпадений паттерна с другими подстроками в тексте используется функция findall() . Она возвращает список всех подстрок, которые соответствуют условиям.

Например, если нужно найти в строке все слова, начинающиеся с латинской «A» в верхнем регистре, или, например, с «a» в любом регистре, необходимо ввести следующее:

Есть еще две функции, которые связаны с findall() : match() и search() . И если findall() возвращает все совпадения в списке, то search() — только первое. Более того, он является конкретным объектом.

Этот объект не содержит значение подстроки, соответствующей паттерну, а всего лишь индексы начала и окончания.

Функция match() ищет совпадение в начале строке; если его нет для первого символа, то двигается дальше и ищет в самой строке. Если совпадений не найдено вовсе, то она ничего не вернет.

В случае успеха же она возвращает то же, что и функция search() .

Агрегация данных

Последний этап работы с данными — агрегация. Он включает в себя преобразование, в результате которого из массива получается целое число. На самом деле, ранее упоминаемые функции sum() , mean() и count() — это тоже агрегация. Они работают с наборами данных и выполняют вычисления, результатом которых всегда является одно значение. Однако более формальный способ, дающий больше контроля над агрегацией, включает категоризацию наборов данных.

Категоризация набора, необходимая для группировки, — это важный этап в процессе обработки данных. Это тоже процесс преобразования, ведь после разделения на группы, применяется функция, которая конвертирует или преобразовывает данные определенным образом в зависимости от того, к какой группе они принадлежат. Часто фазы группировки и применения функции происходит в один шаг.

Также для этого этапа анализа данных pandas предоставляет гибкий и производительный инструмент — GroupBy .

Как и в случае с join те, кто знаком с реляционными базами данных и языком SQL, увидят знакомые вещи. Однако языки, такие как SQL, довольно ограничены, когда их применяют к группам. А вот гибкость таких языков, как Python, со всеми доступными библиотеками, особенно pandas, дает возможность выполнять очень сложные операции.

GroupBy

Теперь разберем в подробностях механизм работы GroupBy . Он использует внутренний механизм, процесс под названием split-apply-combine. Это паттерн, который можно разбить на три фазы, выделив отдельные операции:

  • Разделение — разделение на группы датасетов
  • Применение — применение функции к каждой группе
  • Комбинирование — комбинирование результатов разных групп

Рассмотрите процесс подробно на следующей схеме. На первом этапе, разделении, данные из структуры ( Dataframe или Series ) разделяются на несколько групп в соответствии с заданными критериями: индексами или значениями в колонках. На жаргоне SQL значения в этой колонке называются ключами. Если же вы работаете с двухмерными объектами, такими как Dataframe , критерий группировки может быть применен и к строке ( axis = 0 ), и колонке ( axis = 1 ).

Вторая фаза состоит из применения функции или, если быть точнее, — вычисления, основанного на функции, результатом которого является одно значение, характерное для этой группы.

Последний этап собирает результаты каждой группы и комбинирует их в один объект.

Практический пример

Теперь вы знаете, что процесс агрегации данных в pandas разделен на несколько этапов: разделение-применение-комбинирование. И пусть в библиотеке они не выражены явно конкретными функциями, функция groupby() генерирует объект GroupBy , который является ядром целого процесса.

Для лучшего понимания этого механизма стоит обратиться к реальному примеру. Сперва создадим Dataframe с разными числовыми и текстовыми значениями.

Предположим, нужно посчитать среднюю стоимость в колонке price1 с помощью меток из колонки color . Есть несколько способов, как этого можно добиться. Например, можно получить доступ к колонке price1 и затем вызвать groupby() , где колонка color будет выступать аргументом.

Результат — объект GroupBy . Однако в этой операции не было никаких вычислений; пока что была лишь собрана информация, которая необходима для вычисления среднего значения. Теперь у нас есть group , где все строки с одинаковым значением цвета сгруппированы в один объект.

Чтобы понять, как произошло такое разделение на группы, вызовите атрибут groups для объекта GroupBy .

Как видите, здесь перечислены все группы и явно обозначены строки Dataframe в них. Теперь нужно применить операцию для получения результатов каждой из групп.

Группировка по иерархии

В прошлом разделе данные были сгруппированы по значениям колонки-ключа. Тот же подход можно использовать и для нескольких колонок, сделав группировку нескольких ключей иерархической.

Группировка может работать не только с одной колонкой, но и с несколькими или целым Dataframe . Также если объект GroupBy не потребуется использовать несколько раз, просто удобно выполнять группировки и расчеты за раз, без объявления дополнительных переменных.

Итерация с группировкой

Объект GroupBy поддерживает операцию итерации для генерации последовательности из двух кортежей, содержащих названия групп и их данных.

В последнем примере для иллюстрации был применен вывод переменных. Но операцию вывода на экран можно заменить на функцию, которую требуется применить.

Цепочка преобразований

Из этих примеров должно стать понятно, что при передаче функциям вычисления или другим операциям группировок (вне зависимости от способа их получения) результатом всегда является Series (если была выбрана одна колонка) или Dataframe , сохраняющий систему индексов и названия колонок.

Таким образом становится возможным выбрать одну колонку на разных этапах процесса. Дальше три примера выбора одной колонки на трех разных этапах. Они иллюстрируют гибкость такой системы группировки в pandas.

Но также после операции агрегации имена некоторых колонок могут не нести нужное значение. Поэтому часто оказывается полезным добавлять префикс, объясняющий бизнес-логику такого объединения. Добавление префикса (вместо использования полностью нового имени) помогает отслеживать источник данных. Это важно в случае применения процесса цепочки преобразований (когда Series или Dataframe генерируются друг из друга), где важно отслеживать исходные данные.

Функции для групп

Хотя многие методы не были реализованы специально для GroupBy , они корректно работают с Series . В прошлых примерах было видно, насколько просто получить Series на основе объекта GroupBy , указав имя колонки и применив метод для вычислений. Например, можно использование вычисление квантилей с помощью функции quantiles() .

Также можно определять собственные функции агрегации. Для этого функцию нужно создать и передать в качестве аргумента функции mark() . Например, можно вычислить диапазон значений для каждой группы.

Функция agg() позволяет использовать функции агрегации для всего объекта Dataframe .

Также можно использовать больше функций агрегации одновременно с помощью mark() , передав массив со списком операций для выполнения. Они станут новыми колонками.

Продвинутая агрегация данных

В этом разделе речь пойдет о функциях transform() и apply() , которые позволяют выполнять разные виды операций, включая очень сложные.

Предположим, что в одном Dataframe нужно получить следующее: оригинальный объект (с данными) и полученный с помощью вычисления агрегации, например, сложения.

Благодаря merge() можно сложить результаты агрегации в каждой строке. Но есть и другой способ, работающий за счет transform() . Эта функция выполняет агрегацию, но в то же время показывает значения, сделанные с помощью вычислений на основе ключевого значения в каждой строке Dataframe .

Метод transform() — более специализированная функция с конкретными условиями: передаваемая в качестве аргумента функция должна возвращать одно скалярное значение (агрегацию).

Метод для более привычных GroupBy — это apply() . Он в полной мере реализует схему разделение-применение-комбинирование. Функция разделяет объект на части для преобразования, вызывает функцию для каждой из частей и затем пытается связать их между собой.

Затем Dataframe добавляется колонка с набором текстовых значений, которые будут выступать ключевыми значениями.

Но в этом примере все равно есть повторяющиеся ключи.

Источник статьи: http://pythonru.com/biblioteki/transformacija-dannyh-v-pandas-ch-2-pd-12

Select Rows Containing a Substring in Pandas DataFrame

In this guide, you’ll see how to select rows that contain a specific substring in Pandas DataFrame.

In particular, you’ll observe 5 scenarios to get all rows that:

  1. Contain a specific substring
  2. Contain one substring OR another substring
  3. Do NOT contain given substrings
  4. Contain specific substring in the middle of a string
  5. Contain a specific numeric value

Example of DataFrame

To start with a simple example, let’s create a DataFrame for the following data:

month days_in_month
January 31
February 28
March 31
April 30
May 31
June 30
July 31
August 31
September 30
October 31
November 30
December 31

Here is the code to create the DataFrame in Python:

Once your run the code, you’ll get this DataFrame:

The ultimate goal is to select all the rows that contain specific substrings in the above Pandas DataFrame. Here are 5 scenarios:

5 Scenarios to Select Rows that Contain a Substring in Pandas DataFrame

(1) Get all rows that contain a specific substring

To begin, let’s get all the months that contain the substring of ‘Ju‘ (for the months of ‘June’ and ‘July’):

As you can see, the only two months that contain the substring of ‘Ju’ are June and July:

Note that str.contains() is case sensitive. Meaning that if you specified ‘ju‘ (all in lowercase), while the original values contained a ‘J‘ in uppercase, then you won’t get any selection:

In that case, you’ll get an empty DataFrame:

(2) Get all rows that contain one substring OR another substring

Now let’s get all the months that contain EITHER ‘Ju‘ OR ‘Ma

In that case, you’ll need to use the pipe symbol (‘|’) as follows:

Here are the months that you’ll get:

(3) Get all rows that do NOT contain given substrings

Now let’s select all the months that neither contain ‘Ju’ nor ‘Ma’

’ symbol before the df[‘month’]:

Run the code, and you’ll get the following months:

(4) Get all rows that contain specific substring in the middle of a string

Let’s get all the months that contain ‘uar‘ (for January and February):

You’ll now see the months of January and February:

(5) Get all rows that contain a specific numeric value

What if you’d like to select all the rows that contain a specific numeric value?

For example, what if you want to select all the rows which contain the numeric value of ‘0‘ under the ‘days_in_month’ column?

In that case, you’ll need to convert the ‘days_in_month’ column from integers to strings before you can apply the str.contains():

As you can see, only the months that contain the numeric value of ‘0‘ were selected:

Источник статьи: http://datatofish.com/substring-pandas-dataframe/

Python | Pandas Series.str.find ()

Python — отличный язык для анализа данных, в первую очередь благодаря фантастической экосистеме пакетов Python, ориентированных на данные. Pandas является одним из таких пакетов и значительно упрощает импорт и анализ данных.

str.find() Pandas str.find() используется для поиска подстроки в каждой строке, представленной в серии. Если строка найдена, она возвращает самый низкий индекс своего появления. Если строка не найдена, она вернет -1.

Начальная и конечная точки также могут быть переданы для поиска определенной части строки для переданного символа или подстроки.

Parameters:
sub: String or character to be searched in the text value in series
start: int value, start point of searching. Default is 0 which means from the beginning of string
end: int value, end point where the search needs to be stopped. Default is None.

Return type: Series with index position of substring occurrence

Чтобы загрузить CSV, использованный в коде, нажмите здесь.

В следующих примерах используемый фрейм данных содержит данные некоторых игроков NBA. Изображение фрейма данных перед любыми операциями прилагается ниже.

Пример № 1: Поиск одного символа

В этом примере в каждой строке столбца Name выполняется поиск одного символа «a» с помощью метода str.find (). Начальный и конечный параметры сохраняются по умолчанию. Возвращенный ряд сохраняется в новом столбце, поэтому можно сравнивать индексы, просматривая их напрямую. Перед применением этого метода нулевые строки удаляются с помощью .dropna (), чтобы избежать ошибок.

# удаление столбцов нулевого значения, чтобы избежать ошибок

# создание и передача серии в новый столбец

data[ «Indexes» ] = data[ «Name» ]. str .find(sub)

Выход:
Как показано на выходном изображении, вхождение индекса в столбце «Индексы» равно положению первого вхождения символа в строке. Если подстрока не существует в тексте, возвращается -1. Из первой же строки видно, что «А» не учитывалось, что доказывает, что этот метод чувствителен к регистру.

Пример № 2: Поиск подстроки (более одного символа)

В этом примере подстрока ‘er’ будет найдена в столбце Имя фрейма данных. Параметр start сохраняется равным 2, чтобы начать поиск с 3-го элемента (позиция индекса 2).

# удаление столбцов нулевого значения, чтобы избежать ошибок

# создание и передача серии в новый столбец

data[ «Indexes» ] = data[ «Name» ]. str .find(sub, start)

Выход:
Как показано на выходном изображении, возвращается индекс появления подстроки. Но, как можно видеть, в случае Терри Розье (строка 9 во фрейме данных) вместо первого вхождения ‘er’ было возвращено 10. Это связано с тем, что для параметра start было задано значение 2, а перед ним появляется первый «er».

Источник статьи: http://espressocode.top/python-pandas-series-str-find/

iPython R Rapid Miner

В iPython мои (черновики) упражнения с Python, в разделе «Mining» собраны материалы по R, Rapid Miner, Weka, Gate. в «Projects» фрагменты старых и заготовки для новых исследований. записано для себя, открыто для всех.

Поиск по блогу

Страницы

суббота, 18 апреля 2015 г.

Учимся фильтровать строки DataFrame (pandas) .str.contains()

Чтобы научиться фильтровать строки по условиям вида [pd1[column1] > 100], [pd1[‘col2’].isin(model_list)], [pd1[‘Datem’].str.contains(‘^3.+’)], pd1.dropna(subset = [‘n1_y’, ‘Brandt’, ‘Model’])[10:15] нужно знать форматы столбцов и помнить, что .str.contains() выдает ошибку, если в столбце есть пропущенные значения (NaN) Здесь я сначал хотел попрактиковать регулярные врважения, но оказалось, что подводные камни .str.contains заняли почти весь пост.

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
0 1 Granta Lada 45570 52765 (7,195) -14% 13077 15596 (2,519) -16% 30-4-2014
1 2 Solaris Hyundai 35218 35941 (723) -2% 9774 10553 (779) -7% 30-4-2014
2 3 New Rio KIA 29971 28211 1,760 6% 9045 8430 615 7% 30-4-2014

How to filter the DataFrame rows of pandas by “within”/“in”?¶

Как отобрать строки по численным значениям в столбце? Очень просто.

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
0 1 Granta Lada 45570 52765 (7,195) -14% 13077 15596 (2,519) -16% 30-4-2014
1 2 Solaris Hyundai 35218 35941 (723) -2% 9774 10553 (779) -7% 30-4-2014
2 3 New Rio KIA 29971 28211 1,760 6% 9045 8430 615 7% 30-4-2014
3 4 Duster Renault 28153 25945 2,208 9% 7606 7600 6 0% 30-4-2014
4 5 Kalina Lada 25864 28395 (2,531) -9% 7731 8857 (1,126) -13% 30-4-2014
n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
2 3 New Rio KIA 29971 28211 1,760 6% 9045 8430 615 7% 30-4-2014
3 4 Duster Renault 28153 25945 2,208 9% 7606 7600 6 0% 30-4-2014
4 5 Kalina Lada 25864 28395 (2,531) -9% 7731 8857 (1,126) -13% 30-4-2014

Есть список значений. Выберем из фрейма по этому списку (строк или чисел)¶

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
1 2 Solaris Hyundai 35218 35941 (723) -2% 9774 10553 (779) -7% 30-4-2014
3 4 Duster Renault 28153 25945 2,208 9% 7606 7600 6 0% 30-4-2014
n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
2 3 New Rio KIA 29971 28211 1,760 6% 9045 8430 615 7% 30-4-2014
3 4 Duster Renault 28153 25945 2,208 9% 7606 7600 6 0% 30-4-2014

Теперь объединим оба условия, во втором случае ипользуем волшебный знак

ВНИМАНИЕ. Зто отрицание, которое меняет условие на противоположное.

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
3 4 Duster Renault 28153 25945 2,208 9% 7606 7600 6 0% 30-4-2014
n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
2 3 New Rio KIA 29971 28211 1,760 6% 9045 8430 615 7% 30-4-2014

.str.contains() — это еще та штучка¶

isin() is ideal if you have a list of exact matches, but if you have a list of partial matches or substrings to look for, you can filter using the str.contains method and regular expressions.

Сначала попробуем простейший вариант с поиком по маске. Он отлично работает. В настройках можно поменять умолчания (нас волнцет в первую очередь чуствительность к регистру), вот строка из документации:

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
2 3 New Rio KIA 29971 28211 1,760 6% 9045 8430 615 7% 30-4-2014
20 21 Sportage KIA 9979 10358 (379) -4% 2526 2857 (331) -12% 30-4-2014
n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
2 3 New Rio KIA 29971 28211 1,760 6% 9045 8430 615 7% 30-4-2014
20 21 Sportage KIA 9979 10358 (379) -4% 2526 2857 (331) -12% 30-4-2014
n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
12 13 Octavia A7 Škoda 13171 0 NaN NaN 3753 0 NaN NaN 30-4-2014

В скобках .contains должна быть строка — first argument must be string or compiled pattern, поэтому попытка применить этот метод к числовому столбцу вызывает ошибку

Тогда, попробуем найти подстроку ’99’ в столбце строк ‘u1413m3’ . и снова получим ошибку. и только из-за того, что столбце есть пропуски NaN . Это всерьез подрывает мою веру в человечество:

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
0 1 Granta Lada 45570 52765 (7,195) -14% 13077 15596 (2,519) -16% 30-4-2014
1 2 Solaris Hyundai 35218 35941 (723) -2% 9774 10553 (779) -7% 30-4-2014

Итак, мы нашли здоровенный подводный камень: ПРОПУСКИ данных не обрабатываются в методе .contains()¶

Запомним, что важно соблюдвать (как минимум) два неочевидных условия: обрабатывается только текстовый столбец, и без пропусков данных NaN

.str.contains и регулярные выражения¶

Здесь мой справочник Regular Expressions Python . и мой перечень главных команд , так что сначала проверим синтаксис .str.contains(), а потом поэкспериментируем с выражениями regexp

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
0 1 Granta Lada 45570 52765 (7,195) -14% 13077 15596 (2,519) -16% 30-4-2014
1 2 Solaris Hyundai 35218 35941 (723) -2% 9774 10553 (779) -7% 30-4-2014

Вот вариант отобрать строки, в которых нет пропусков данных NaN

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
0 1 Granta Lada 45570 52765 (7,195) -14% 13077 15596 (2,519) -16% 30-4-2014
1 2 Solaris Hyundai 35218 35941 (723) -2% 9774 10553 (779) -7% 30-4-2014

А теперь попробуем к этому новому набору применить .str.contains, скопипастим еще одно условие из работающего примера выше и добавим, . работает:

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
0 1 Granta Lada 45570 52765 (7,195) -14% 13077 15596 (2,519) -16% 30-4-2014
1 2 Solaris Hyundai 35218 35941 (723) -2% 9774 10553 (779) -7% 30-4-2014

А теперь попробуем неработавшиий ранее (из-за пропусков) пример и снова получим ту же ошибку:

Не могу отфильтровать пропуски ни одним из методов, оказывается для них есть специальные методы

How to drop rows of Pandas dataframe whose value of certain column is NaN¶

Это нейтронная бомба, которая убивает все строки с Nan в любых столбцах, в примере внизу нет строки 12

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
10 11 Logan Renault 14342 16674 (2,332) -14% 3796 4890 (1,094) -22% 30-4-2014
11 12 Sandero Renault 13777 14464 (687) -5% 3796 4084 (288) -7% 30-4-2014
13 14 4×4 Lada 12931 14599 (1,668) -11% 3784 3808 (24) -1% 30-4-2014
14 15 RAV 4 Toyota 12501 11410 1,091 10% 4391 4974 (583) -12% 30-4-2014
15 16 Cruze Chevrolet 12363 14565 (2,202) -15% 3014 4284 (1,270) -30% 30-4-2014

А вот более точный вариант для конкретного подмножества столбцов, здесь мы берем столбцы без пропусков, и 12 строка появляется.

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
10 11 Logan Renault 14342 16674 (2,332) -14% 3796 4890 (1,094) -22% 30-4-2014
11 12 Sandero Renault 13777 14464 (687) -5% 3796 4084 (288) -7% 30-4-2014
12 13 Octavia A7 Škoda 13171 0 NaN NaN 3753 0 NaN NaN 30-4-2014
13 14 4×4 Lada 12931 14599 (1,668) -11% 3784 3808 (24) -1% 30-4-2014
14 15 RAV 4 Toyota 12501 11410 1,091 10% 4391 4974 (583) -12% 30-4-2014

Еще раз обращаю внимание на этот пост, здесь все варианты ответов How to drop rows of Pandas dataframe whose value of certain column is NaN¶

И вот этот вариант тоже рабочий

А вот этот наворот с numpy у меня не работает.

Теперь мы можем решить задачку, когда в столбце есть Nan¶

Сначала мы убираем строки, в которых есть Nan в столбце ‘u1413m3’, создаем новый объект DataFrame, а с ним уже работает метод str.contains()

n1_y Model Brandt 2014y3 2013y3 u1413y3 1413y3 2014m3 2013m3 u1413m3 1413m3 Datem
17 18 Focus Ford 10923 22278 (11,355) -51% 2549 5546 (2,997) -54% 30-4-2014

Казалось бы, решение найдено. но чтоя буду делать с этип общипанным новым объектом? Можно ли не создавать дополнитеьный объект?

Оказывается, что нельзя. Начинается переиндексация, а потом, когда выясняется, что старый индекс поломан после того, как убрали строку с Nan, то встает вопрос, какой индекс использовать:

Источник статьи: http://pythonr.blogspot.com/2015/04/dataframe-pandas-strcontains.html

Python Pandas – Работа с текстовыми данными

В этой главе мы обсудим строковые операции с нашей базовой серией / индексом. В последующих главах мы узнаем, как применять эти строковые функции к DataFrame.

Pandas предоставляет набор строковых функций, которые облегчают работу со строковыми данными. Наиболее важно, что эти функции игнорируют (или исключают) отсутствующие значения / NaN.

Почти все эти методы работают со строковыми функциями Python (см .: https://docs.python.org/3/library/stdtypes.html#string-methods ). Итак, преобразуйте объект Series в объект String и затем выполните операцию.

Давайте теперь посмотрим, как выполняется каждая операция.

Преобразует строки в Series / Index в нижний регистр.

Преобразует строки в Series / Index в верхний регистр.

Помогает удалить пробелы (включая перевод строки) из каждой строки в Серии / индексе с обеих сторон.

Разбивает каждую строку по заданному шаблону.

Объединяет элементы серии / индекса с указанным разделителем.

Возвращает DataFrame с закодированными значениями One-Hot.

Возвращает логическое значение True для каждого элемента, если подстрока содержится в элементе, иначе False.

Заменяет значение a значением b .

Повторяет каждый элемент с указанным числом раз.

Возвращает количество появлений шаблона в каждом элементе.

Возвращает true, если элемент в Series / Index начинается с шаблона.

Возвращает true, если элемент в Series / Index заканчивается шаблоном.

Возвращает первую позицию первого вхождения шаблона.

Возвращает список всех вхождений шаблона.

Меняет местами корпус нижний / верхний.

Проверяет, все ли символы в каждой строке в Серии / Индексе в нижнем регистре или нет. Возвращает логическое значение

Проверяет, все ли символы в каждой строке в Серии / Индексе в верхнем регистре или нет. Возвращает логическое значение.

Проверяет, являются ли все символы в каждой строке в Серии / Индексе числовыми. Возвращает логическое значение.

Преобразует строки в Series / Index в нижний регистр.

Преобразует строки в Series / Index в верхний регистр.

Помогает удалить пробелы (включая перевод строки) из каждой строки в Серии / индексе с обеих сторон.

Разбивает каждую строку по заданному шаблону.

Объединяет элементы серии / индекса с указанным разделителем.

Возвращает DataFrame с закодированными значениями One-Hot.

Возвращает логическое значение True для каждого элемента, если подстрока содержится в элементе, иначе False.

Заменяет значение a значением b .

Повторяет каждый элемент с указанным числом раз.

Возвращает количество появлений шаблона в каждом элементе.

Возвращает true, если элемент в Series / Index начинается с шаблона.

Возвращает true, если элемент в Series / Index заканчивается шаблоном.

Возвращает первую позицию первого вхождения шаблона.

Возвращает список всех вхождений шаблона.

Меняет местами корпус нижний / верхний.

Проверяет, все ли символы в каждой строке в Серии / Индексе в нижнем регистре или нет. Возвращает логическое значение

Проверяет, все ли символы в каждой строке в Серии / Индексе в верхнем регистре или нет. Возвращает логическое значение.

Проверяет, являются ли все символы в каждой строке в Серии / Индексе числовыми. Возвращает логическое значение.

Давайте теперь создадим серию и посмотрим, как работают все вышеперечисленные функции.

Его вывод выглядит следующим образом –

Его вывод выглядит следующим образом –

Верхняя ()

Его вывод выглядит следующим образом –

Его вывод выглядит следующим образом –

полоса ()

Его вывод выглядит следующим образом –

сплит (шаблон)

Его вывод выглядит следующим образом –

кошка (сентябрь = шаблон)

Его вывод выглядит следующим образом –

get_dummies ()

Его вывод выглядит следующим образом –

содержит ()

Его вывод выглядит следующим образом –

заменить (а, б)

Его вывод выглядит следующим образом –

повтор (значение)

Его вывод выглядит следующим образом –

кол-(шаблон)

Его вывод выглядит следующим образом –

StartsWith (шаблон)

Его вывод выглядит следующим образом –

EndsWith (шаблон)

Его вывод выглядит следующим образом –

найти (шаблон)

Его вывод выглядит следующим образом –

«-1» означает, что в элементе нет такого шаблона.

FindAll (шаблон)

Его вывод выглядит следующим образом –

Пустой список ([]) указывает, что в элементе нет такого шаблона.

swapcase ()

Его вывод выглядит следующим образом –

ISLOWER ()

Его вывод выглядит следующим образом –

ISUPPER ()

Его вывод выглядит следующим образом –

IsNumeric ()

Его вывод выглядит следующим образом –

Источник статьи: http://coderlessons.com/tutorials/python-technologies/vyuchit-python-panda/python-pandas-rabota-s-tekstovymi-dannymi

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Sr.No Описание функции
1