Методы строк объектов Series/Index в pandas, объект Series.str

Векторизованные строковые функции для Series и Index

Объект Series.str создан по образцу строковых методов Python с некоторым вдохновением от пакета stringr языка R.

Синтаксис:

# объект `Series.str`
s = Series.str.split()
# или
s = Series.str.replace()

Описание:

Объект Series.str и Index.str модуля pandas предоставляет векторизованные строковые функции для Series и Index соответственно. Другими словами, Series/Index оснащены набором методов обработки строк, которые позволяют легко работать с каждым элементом массива.

Доступ к методам строк осуществляется через атрибут .str, и обычно их имена соответствуют эквивалентным (скалярным) встроенным методам строк Python.

Примечание: Цепочки методов. API строк pandas обрабатывает только одну операцию за раз, следовательно, необходимо продолжать вызывать объект Series.str после каждой операции со строками. Не совсем элегантно, но что поделать.
Например:
s = Series.str.replace(' ', '_').str.replace('.', '_').str.strip('_').str.lower().str.len()

Пример для элементов Series:

>>> import pandas as pd
>>> s = pd.Series(["A_Str_Series"])
>>> s
# 0    A_Str_Series
# dtype: object

>>> s.str.split("_")
# 0    [A, Str, Series]
# dtype: object

>>> s.str.replace("_", "")
# 0    AStrSeries
# dtype: object

Для элементов Index:

>>> import pandas as pd
>>> df = pd.DataFrame(columns=['aa dd', 'dd.d_', 'd._'])
>>> df
# Empty DataFrame
# Columns: [aa dd, dd.d_, d._]
# Index: []

>>> df.columns.str.replace('[\s+.]', '_').str.strip('_')
# Index(['aa dd', 'dd.d', 'd.'], dtype='object')

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

Возможно, самое главное, эти методы автоматически исключают отсутствующие значения/значения NA. То есть, строки 'NA' остаются строками 'NA', если не обрабатываются иным образом определенным методом.

Примечание: Методы строк, возвращающие значение bool в конечном результате возвращают Series/Index этих значений. Как работать с такими объектами читайте в материале "Логическая индексация в Pandas".

Встроенные методы в объект `Series.str`

Полные эквиваленты встроенных методов строк Python (включая принимаемые аргументы):
- Series.str.capitalize() - эквивалентен str.capitalize().
- Series.str.casefold() - эквивалентен str.casefold().
- Series.str.center() - эквивалентен str.center().
- Series.str.decode() - эквивалентен bytes.decode().
- Series.str.encode() - эквивалентен str.encode().
- Series.str.endswith() - эквивалентен str.endswith().
- Series.str.find() - эквивалентен str.find().
- Series.str.index() - эквивалентен str.index().
- Series.str.join() - эквивалентен str.join().
- Series.str.ljust() - эквивалентен str.ljust().
- Series.str.lower() - эквивалентен str.lower().
- Series.str.lstrip() - эквивалентен str.lstrip().
- Series.str.rfind() - эквивалентен str.rfind().
- Series.str.rindex() - эквивалентен str.rindex().
- Series.str.rjust() - эквивалентен str.rjust().
- Series.str.rstrip() - эквивалентен str.rstrip().
- Series.str.startswith() - эквивалентен str.startswith().
- Series.str.strip() - эквивалентен str.strip().
- Series.str.swapcase() - эквивалентен str.swapcase().
- Series.str.title() - эквивалентен str.title().
- Series.str.translate() - эквивалентен str.translate().
- Series.str.upper() - эквивалентен str.upper().
- Series.str.isalnum() - эквивалентен str.isalnum().
- Series.str.isalpha() - эквивалентен str.isalpha().
- Series.str.isdigit() - эквивалентен str.isdigit().
- Series.str.isspace() - эквивалентен str.isspace().
- Series.str.islower() - эквивалентен str.islower().
- Series.str.isupper() - эквивалентен str.isupper().
- Series.str.istitle() - эквивалентен str.istitle().
- Series.str.isnumeric() - эквивалентен str.isnumeric().
- Series.str.isdecimal() - эквивалентен str.isdecimal().
Методы строк библиотеки Pandas (или отличие принимаемых аргументов):
- Series.str.len() вычисляет длину каждого элемента в Series/Index;
- Series.str.cat() объединяет строки в Series/Index с заданным разделителем;
- Series.str.count() считает количество повторений определенного шаблона регулярного выражения;
- Series.str.extract() извлекает группы захвата из регулярного выражения в виде столбцов, создавая DataFrame;
- Series.str.extractal()l извлекает группы из всех совпадений с регулярным выражением, создавая DataFrame;
- Series.str.match() определяет, начинается ли каждая строка с совпадения с регулярным выражением;
- Series.str.findall() найдет все вхождения шаблона или регулярного выражения;
- Series.str.fullmatch() определяет, полностью ли каждая строка соответствует регулярному выражению;
- Series.str.get() извлекает элемент из строки по индексу;
- Series.str.normalize() возвращает нормальную форму Юникода для строк;
- Series.str.pad() дополняет строки до заданной ширины;
- Series.str.partition() делит каждую строку по первому вхождению;
- Series.str.removeprefix() удаляет префикс из строки;
- Series.str.removeprefix() удаляет префикс из каждой строки;
- Series.str.removesuffix() удаляет суффикс из каждой строки;
- Series.str.repeat() дублирует каждую строку нужное количество раз;
- Series.str.replace() заменяет каждое вхождение шаблона регулярного выражения;
- Series.str.rpartition() делит строку при последнем вхождении символа-разделителя;
- Series.str.slice() берет срез строки;
- Series.str.slice_replace() заменяет срез строки;
- Series.str.split() разбивает строки по заданному разделителю;
- Series.str.rsplit() разбивает строки по заданному разделителю начиная с конца;
- Series.str.wrap() внутренне метод использует textwrap.TextWrapper с настройками по умолчанию;
- Series.str.zfill() дополняет строки до заданной ширины;
- Series.str.get_dummies() возвращает DataFrame фиктивных/индикаторных переменных.

Специфичные методы строк библиотеки Pandas

`Series.str.len()`:

Метод Series.str.len() вычисляет длину каждого элемента в Series/Index. Элемент может быть последовательностью (например, строкой, кортежем или списком) или коллекцией (например, словарем).

Метод возвращает Series или Index целочисленных значений, указывающих длину каждого элемента в серии или индексе.

Примеры:

>>> import pandas as pd
s = pd.Series(['dog',
                '',
                5,
                {'foo' : 'bar'},
                [2, 3, 5, 7],
                ('one', 'two', 'three')])
>>> s
# 0                  dog
# 1
# 2                    5
# 3       {'foo': 'bar'}
# 4         [2, 3, 5, 7]
# 5    (one, two, three)
# dtype: object

>>> s.str.len()
# 0    3.0
# 1    0.0
# 2    NaN
# 3    1.0
# 4    4.0
# 5    3.0
# dtype: float64

Особенность. Если строки имеют начальные/конечные пробелы и их нужно исключить из подсчета, то необходимо использовать "цепочку" методов следующим образом: Series.str.strip().str.len(). Другими словами, необходимо продолжать вызывать объект Series.str после каждой операции со строками.

`Series.str.cat(others=None, sep=None, na_rep=None, join='left')`:

Метод Series.str.cat() объединяет строки в Series или Index с заданным разделителем sep. Если указан аргумент others, то метод объединяет Series/Index и элементы others поэлементно. Если others не передан, то все значения в Series/Index объединяются в одну строку с заданным значением sep.

Аргументы:

others=None - Series, Index, DataFrame, np.ndarray (одномерный или двумерный) и другие списки строк - должны иметь ту же длину, что и вызывающий Series/Index, за исключением индексированных объектов (т.е. Series/Index/DataFrame), если аргумент join не равно None.
- Если other является списком, содержащим комбинацию Series, Index или np.ndarray (1-dim), то все элементы будут распакованы и по отдельности должны удовлетворять вышеуказанным критериям.
- Если others имеет значение None, то метод возвращает конкатенацию всех строк в вызывающем Series/Index.
sep=None - разделитель между элементами/столбцами. По умолчанию используется пустая строка ''.
na_rep=None - представление, которое вставляется для всех отсутствующих NA значений:
- Если na_rep=None и other=None, отсутствующие значения в Series/Index опускаются из результата.
- Если na_rep=None, а others не None, то строка, содержащая отсутствующее значение в любом из столбцов (до конкатенации), в результате будет иметь отсутствующее значение.
join='left' - определяет стиль соединения между вызывающим объектом Series/Index и любым объектом Series/Index/DataFrame аргумента others (объекты без индекса должны соответствовать длине вызывающего объекта Series/Index). Чтобы отключить выравнивание, нужно использовать метод .values объектов Series/Index/DataFrame.

Если others=None, то возвращается str, в противном случае возвращается Series/Index (того же типа, что и вызывающий объект).

Примеры:

Если аргумент others=None, все значения объединяются в одну строку:

>>> s = pd.Series(['a', 'b', np.nan, 'd'])
>>> s.str.cat(sep=' ')
# 'a b d'

По умолчанию значения NA игнорируются. Используя аргумент na_rep, им можно передать значение:

>>> s.str.cat(sep=' ', na_rep='?')
# 'a b ? d'

Если указан аргумент others, то соответствующие значения объединяются с помощью разделителя sep с каждым элементом вызывающего Series. Результатом будет Series строк.

>>> s.str.cat(['A', 'B', 'C', 'D'], sep=',')
# 0    a,A
# 1    b,B
# 2    NaN
# 3    d,D
# dtype: object

Значения NA в результирующей строке останутся пустыми (предыдущий пример), но им можно передать значение с помощью аргумента na_rep.

>>> s.str.cat(['A', 'B', 'C', 'D'], na_rep='-')
# 0    aA
# 1    bB
# 2    -C
# 3    dD
# dtype: object

Серии с разными индексами можно выровнять перед объединением. Аргумент join работает так же, как и в DataFrame.join().

>>> t = pd.Series(['d', 'a', 'e', 'c'], index=[3, 0, 4, 2])
>>> s.str.cat(t, join='left', na_rep='-')
# 0    aa
# 1    b-
# 2    -c
# 3    dd
# dtype: object

>>> s.str.cat(t, join='outer', na_rep='-')
# 0    aa
# 1    b-
# 2    -c
# 3    dd
# 4    -e
# dtype: object

>>> s.str.cat(t, join='inner', na_rep='-')
# 0    aa
# 2    -c
# 3    dd
# dtype: object

>>> s.str.cat(t, join='right', na_rep='-')
# 3    dd
# 0    aa
# 4    -e
# 2    -c
# dtype: object

`Series.str.contains(pat, case=True, flags=0, na=None, regex=True)`:

Метод Series.str.contains() проверяет, содержится ли шаблон pat или регулярное выражение pat в каждой строке Series/Index.

Полное описание метода Series.str.contains() смотрите в материале "Использование регулярных выражений в Pandas".

`Series.str.count(pat, flags=0)`:

Метод Series.str.count() используется для подсчета количества повторений определенного шаблона регулярного выражения в каждом из строковых элементов Series.

Полное описание метода Series.str.count() смотрите в материале "Использование регулярных выражений в Pandas".

`Series.str.extract(pat, flags=0, expand=True)`:

Метод Series.str.extract() извлекает группы захвата из шаблона регулярного выражения pat в виде столбцов, создавая DataFrame. Для каждой соответствующей строки в Series извлекает группы из первого совпадения с регулярным выражением pat.

Полное описание метода Series.str.extract() смотрите в материале "Использование регулярных выражений в Pandas".

`Series.str.extractall(pat, flags=0)`:

Метод Series.str.extractall() для каждой строки объекта Series извлекает группы из всех совпадений с регулярным выражением pat. Когда каждая подстрока строки в Series имеет ровно одно совпадение, то extractall(pat).xs(0, level=’match’) совпадает с extract(pat).

Аргументы:

pat - шаблон регулярного выражения с группами захвата.
flags=0 - флаги модуля re, например re.IGNORECASE. Они позволяют изменять соответствие регулярных выражений для таких вещей, как регистр, пробелы и т. д. Несколько флагов можно комбинировать с помощью побитового оператора ИЛИ, например re.IGNORECASE | re.MULTILINE.

Примеры:

Шаблон с одной группой вернет DataFrame с одним столбцом. Индексы, не имеющие совпадений, в результате не появятся.

>>> s = pd.Series(["a1a2", "b1", "c1"], index=["A", "B", "C"])
>>> s.str.extractall(r"[ab](\d)")
#         0
# match
# A 0      1
#   1      2
# B 0      1

Имена групп захвата используются в качестве имен столбцов результата.

>>> s.str.extractall(r"[ab](?P<digit>\d)")
#         digit
# match
# A 0         1
#   1         2
# B 0         1

Шаблон с двумя группами вернет DataFrame с двумя столбцами.

>>> s.str.extractall(r"(?P<letter>[ab])(?P<digit>\d)")
#         letter digit
# match
# A 0          a     1
#   1          a     2
# B 0          b     1

Необязательные группы, которые не совпадают, в результате имеют значение NaN.

>>> s.str.extractall(r"(?P<letter>[ab])?(?P<digit>\d)")
#         letter digit
# match
# A 0          a     1
#   1          a     2
# B 0          b     1
# C 0        NaN     1

`Series.str.match(pat, case=True, flags=0, na=None)`:

Метод Series.str.match() определяет, начинается ли каждая строка с совпадения с регулярным выражением.

Полное описание метода Series.str.match() смотрите в материале "Использование регулярных выражений в Pandas".

`Series.str.findall(pat, flags=0)`:

Метод Series.str.findall() найдет все вхождения шаблона или регулярного выражения pat в Series/Index. Эквивалентно применению re.findall() ко всем элементам в Series/Index.

Полное описание метода Series.str.findall() смотрите в материале "Использование регулярных выражений в Pandas".

`Series.str.fullmatch(pat, case=True, flags=0, na=None)`:

Метод Series.str.fullmatch() определяет, полностью ли каждая строка соответствует регулярному выражению.

Аргументы:

pat - строка или регулярное выражение.
case=True - если True, то учитывается регистр.
flags=0 - флаги модуля re, например, re.IGNORECASE.
na=None - заполняет значение для значений NA. Значение по умолчанию зависит от типа массива. Для типа object используется numpy.nan. Для StringDtype используется pandas.NA.

Примеры:

>>> ser = pd.Series(["cat", "duck", "dove"])
>>> ser.str.fullmatch(r'd.+')
# 0   False
# 1    True
# 2    True
# dtype: bool

Используя логическую индексацию выведем совпавшие строки:

>>> ser[ser.str.fullmatch(r'd.+')]
# 1    duck
# 2    dove
# dtype: objec

`Series.str.get(i)`:

Метод Series.str.get() извлекает элемент из каждого элемента Series/Index по по индексу или с помощью указанного ключа (i).

В основном применяется для извлечения элемента из списков, кортежей, словарей или строк в каждом элементе Series/Index.

Примеры:

s = pd.Series(["String",
              (1, 2, 3),
              ["a", "b", "c"],
              123,
              -456,
              {1: "Hello", "2": "World"}])
>>> s
# 0                        String
# 1                     (1, 2, 3)
# 2                     [a, b, c]
# 3                           123
# 4                          -456
# 5    {1: 'Hello', '2': 'World'}
# dtype: object

>>> s.str.get(1)
# 0        t
# 1        2
# 2        b
# 3      NaN
# 4      NaN
# 5    Hello
# dtype: object

>>> s.str.get(-1)
# 0      g
# 1      3
# 2      c
# 3    NaN
# 4    NaN
# 5    None
# dtype: object

Возвращаемый элемент с заданным ключом

s = pd.Series([{"name": "Hello", "value": "World"},
              {"name": "Goodbye", "value": "Planet"}])

>>> s.str.get('name')
# 0      Hello
# 1    Goodbye
# dtype: object

`Series.str.normalize(form)`:

Метод Series.str.normalize() возвращает нормальную форму Юникода для строк в Series/Index.

Дополнительные сведения о формах смотрите в unicodedata.normalize().

Аргумент form представляет собой форму Unicode. Принимает значения 'NFC', 'NFKC', 'NFD', 'NFKD'.

Примеры:

>>> ser = pd.Series(['ñ'])
>>> ser.str.normalize('NFC') == ser.str.normalize('NFD')
# 0   False
# dtype: bool

`Series.str.pad(width, side='left', fillchar=' ')`:

Метод Series.str.pad() дополняет строки Series/Index до заданной ширины.

Аргументы:

width - минимальная ширина результирующей строки.
side='left - сторона, с которой нужно заполнить строку. Принимает значения: 'left', 'right', 'both'
fillchar=' ' - символ для заполнения строки.

Примеры:

>>> s = pd.Series(["caribou", "tiger"])
>>> s
# 0    caribou
# 1      tiger
# dtype: object

>>> s.str.pad(width=10)
# 0       caribou
# 1         tiger
# dtype: object

>>> s.str.pad(width=10, side='right', fillchar='-')
# 0    caribou---
# 1    tiger-----
# dtype: object

>>> s.str.pad(width=10, side='both', fillchar='-')
# 0    -caribou--
# 1    --tiger---
# dtype: object

`Series.str.partition(sep=' ', expand=True)`:

Метод Series.str.partition() делит каждую строку Series/Index по первому вхождению sep.

Этот метод разделяет строку при первом вхождении sep и возвращает 3 элемента, содержащие часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, то возвращаем 3 элемента, содержащие саму строку, за которыми следуют две пустые строки.

Аргументы:

sep=' ' - строка-разделитель.
expand=True - если значение True, то возвращается расширяющаяся размерность DataFrame/MultiIndex. Если False, возвращает Series/Index.

Примеры:

>>> s = pd.Series(['Linda van der Berg', 'George Pitt-Rivers'])
>>> s
# 0    Linda van der Berg
# 1    George Pitt-Rivers
# dtype: object

>>> s.str.partition()
#         0  1             2
# 0   Linda     van der Berg
# 1  George      Pitt-Rivers

Для разбиения по последнему пробелу вместо первого:

>>> s.str.rpartition()
#                0  1            2
# 0  Linda van der            Berg
# 1         George     Pitt-Rivers

Использование аргумента sep:

>>> s.str.partition('-')
#                     0  1       2
# 0  Linda van der Berg
# 1         George Pitt  -  Rivers

Возвращаем Series, содержащую кортежи, вместо DataFrame:

>>> s.str.partition('-', expand=False)
# 0    (Linda van der Berg, , )
# 1    (George Pitt, -, Rivers)
# dtype: object

Также доступно по индексам:

>>> idx = pd.Index(['X 123', 'Y 999'])
>>> idx
# Index(['X 123', 'Y 999'], dtype='object')

Который создаст MultiIndex:

>>> idx.str.partition()
# MultiIndex([('X', ' ', '123'),
#             ('Y', ' ', '999')],
#            )

Или индекс с кортежами с expand=False:

>>> idx.str.partition(expand=False)
# Index([('X', ' ', '123'), ('Y', ' ', '999')], dtype='object')

`Series.str.removeprefix(prefix)`:

Метод Series.str.removeprefix() удаляет префикс prefix из каждой строки Series. Если префикс отсутствует, то будет возвращена исходная строка.

Примеры:

>>> s = pd.Series(["str_foo", "str_bar", "no_prefix"])
>>> s
# 0    str_foo
# 1    str_bar
# 2    no_prefix
# dtype: object

>>> s.str.removeprefix("str_")
# 0    foo
# 1    bar
# 2    no_prefix
# dtype: object

`Series.str.removesuffix(suffix)`:

Метод Series.str.removesuffix() удаляет суффикс suffix из каждой строки Series. Если суффикс отсутствует, то будет возвращена исходная строка.

Примеры:

>>> s = pd.Series(["foo_str", "bar_str", "no_suffix"])
>>> s
# 0    foo_str
# 1    bar_str
# 2    no_suffix
# dtype: object

>>> s.str.removesuffix("_str")
# 0    foo
# 1    bar
# 2    no_suffix
# dtype: object

`Series.str.repeat(repeats)`:

Метод Series.str.repeat() дублирует каждую строку в Series/Index.

Аргумент repeats принимает целое число или их список. Одно число означает - повторить каждую строку Series/Index столько-то раз. Список целых значений говорит о том, что нужно повторить каждую строку Series/Index конкретное число раз.

Примеры:

>>> s = pd.Series(['a', 'b', 'c'])
>>> s
# 0    a
# 1    b
# 2    c
# dtype: object

Одиночный int последовательно повторяет все строки

>>> s.str.repeat(repeats=2)
# 0    aa
# 1    bb
# 2    cc
# dtype: object

Список значений int последовательно повторяет соответствующую строку

>>> s.str.repeat(repeats=[1, 2, 3])
# 0      a
# 1     bb
# 2    ccc
# dtype: object

`Series.str.replace()`:

Метод Series.str.replace() заменит каждое вхождение шаблона регулярного выражения pat в pandas.Series/pandas.Index. Эквивалентно str.replace() и re.sub().

Полное описание метода Series.str.replace() смотрите в материале "Использование регулярных выражений в Pandas".

`Series.str.rpartition(sep=' ', expand=True)`:

Метод Series.str.rpartition() делит строку при последнем вхождении символа-разделителя sep.

Этот метод разделяет строку при последнем вхождении sep и возвращает 3 элемента, содержащих часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает 3 элемента, содержащих две пустые строки, за которыми следует сама строка.

Аргументы:

sep=' ' - строка-разделитель.
expand=True - если значение True, то возвращается расширяющаяся размерность DataFrame/MultiIndex. Если False, возвращает Series/Index.

Примеры:

>>> s = pd.Series(['Linda van der Berg', 'George Pitt-Rivers'])
>>> s
# 0    Linda van der Berg
# 1    George Pitt-Rivers
# dtype: object

>>> s.str.rpartition()
#                0  1            2
# 0  Linda van der            Berg
# 1         George     Pitt-Rivers

Дополнительно смотрите примеры метода Series.str.partition()

`Series.str.slice(start=None, stop=None, step=None)`:

Метод Series.str.slice() берет срез строки из каждого элемента в Series/Index.

Аргументы:

start=None - левая позиция индекса, используемая для среза.
stop=None - правая позиция индекса, используемая для среза.
step=None - размер шага для операции среза.

Примеры:

>>> s = pd.Series(["koala", "dog", "chameleon"])
>>> s
# 0        koala
# 1          dog
# 2    chameleon
# dtype: object

>>> s.str.slice(start=1)
# 0        oala
# 1          og
# 2    hameleon
# dtype: object

>>> s.str.slice(start=-1)
# 0           a
# 1           g
# 2           n
# dtype: object

>>> s.str.slice(stop=2)
# 0    ko
# 1    do
# 2    ch
# dtype: object

>>> s.str.slice(step=2)
# 0      kaa
# 1       dg
# 2    caeen
# dtype: object

>>> s.str.slice(start=0, stop=5, step=3)
# 0    kl
# 1     d
# 2    cm
# dtype: object

Эквивалентное поведение:

>>> s.str[0:5:3]
# 0    kl
# 1     d
# 2    cm
# dtype: object

`Series.str.slice_replace(start=None, stop=None, repl=None)`:

Метод Series.str.slice_replace() заменяет позиционный фрагмент строки другим значением.

Аргументы:

start=None - левая позиция индекса, используемая для среза. Если не указано, то срез не ограничен слева, т. е. срез начинается с начала строки.
stop=None - правая позиция индекса, используемая для среза. Если не указано, то срез не ограничен справа, т. е. срез осуществляется до конца строки.
step=None - строка для замены. Если не указано, то вырезанная область заменяется пустой строкой.

Примеры:

>>> s = pd.Series(['a', 'ab', 'abc', 'abdc', 'abcde'])
>>> s
# 0        a
# 1       ab
# 2      abc
# 3     abdc
# 4    abcde
# dtype: object

Укажем только аргумент start, что означает замену от start до конца строки.

>>> s.str.slice_replace(1, repl='X')
# 0    aX
# 1    aX
# 2    aX
# 3    aX
# 4    aX
# dtype: object

Укажем только аргумент stop, что означает, что начало строки до позиции stop заменяется на repl, а остальная часть строки остается неизменной.

>>> s.str.slice_replace(stop=2, repl='X')
# 0       X
# 1       X
# 2      Xc
# 3     Xdc
# 4    Xcde
# dtype: object

Теперь укажем start и stop, что означает, что срез от позиции start до stop заменяется на repl.

>>> s.str.slice_replace(start=1, stop=3, repl='X')
# 0      aX
# 1      aX
# 2      aX
# 3     aXc
# 4    aXde
# dtype: object

`Series.str.split(pat=None, , n=-1, expand=False, regex=None)`*:

Метод Series.str.split() разбивает строки в Series/Index по заданному разделителю pat начиная с начала n количество раз.

Полное описание метода Series.str.split() смотрите в материале "Использование регулярных выражений в Pandas".

`Series.str.rsplit(pat=None, , n=-1, expand=False, regex=None)`*:

Метод Series.str.rsplit() разбивает строки в Series/Index по заданному разделителю pat начиная с конца n количество раз.

Полное описание метода Series.str.rsplit() смотрите в материале "Использование регулярных выражений в Pandas".

*`Series.str.wrap(width, **kwargs)`*:

Метод Series.str.wrap() оборачивает каждую строку Series/Index так, чтобы каждая строка имела длину не более width символов по ширине. Внутренне этот метод использует textwrap.TextWrapper с настройками по умолчанию.

Аргументы:

width - максимальная длина строки.
**kwargs - ключевые аргументы для передачи классу textwrap.TextWrapper.

Примеры:

>>> s = pd.Series(['line to be wrapped', 'another line to be wrapped'])
>>> s.str.wrap(12)
# 0             line to be\nwrapped
# 1    another line\nto be\nwrapped
# dtype: object

`Series.str.zfill(width)`:

Метод Series.str.zfill() дополняет строки в Series/Index до заданной ширины width. Строки дополняются символами '0' слева. Строки Series/Index, длина которых больше или равна ширине width, не изменяются.

Примеры:

Отличается от str.zfill(), который имеет специальную обработку '+'/'-' в строке.

>>> s = pd.Series(['-1', '1', '1000', 10, np.nan])
>>> s
# 0      -1
# 1       1
# 2    1000
# 3      10
# 4     NaN
# dtype: object

Обратите внимание, что 10 и NaN не являются строками, поэтому они преобразуются в NaN. Знак минус в '-1' рассматривается как специальный символ, и справа от него добавляется ноль (str.zfill() переместил бы его влево). 1000 остается неизменным, так как он длиннее ширины.

>>> s.str.zfill(3)
# 0     -01
# 1     001
# 2    1000
# 3     NaN
# 4     NaN
# dtype: object

`Series.str.get_dummies(sep='|')`:

Метод Series.str.get_dummies() возвращает DataFrame фиктивных/индикаторных переменных для Series.

Каждая строка в Series разбивается на sep и возвращается в виде DataFrame "фиктивных" (0) и "индикаторных" (1) значений.

Примеры:

>>> pd.Series(['a|b', 'a', 'a|c']).str.get_dummies()
#    a  b  c
# 0  1  1  0
# 1  1  0  0
# 2  1  0  1

>>> pd.Series(['a|b', np.nan, 'a|c']).str.get_dummies()
#    a  b  c
# 0  1  1  0
# 1  0  0  0
# 2  1  0  1

Дополнительно смотрите материал "Функция get_dummies() и from_dummies() модуля pandas"

Методы строк объектов Series/Index в pandas, объект Series.str

Векторизованные строковые функции для Series и Index

Синтаксис:

Описание:

Встроенные методы в объект Series.str

Специфичные методы строк библиотеки Pandas

Series.str.len():

Series.str.cat(others=None, sep=None, na_rep=None, join='left'):

Series.str.contains(pat, case=True, flags=0, na=None, regex=True):

Series.str.count(pat, flags=0):

Series.str.extract(pat, flags=0, expand=True):

Series.str.extractall(pat, flags=0):

Series.str.match(pat, case=True, flags=0, na=None):

Series.str.findall(pat, flags=0):

Series.str.fullmatch(pat, case=True, flags=0, na=None):

Series.str.get(i):

Series.str.normalize(form):

Series.str.pad(width, side='left', fillchar=' '):

Series.str.partition(sep=' ', expand=True):

Series.str.removeprefix(prefix):

Series.str.removesuffix(suffix):

Series.str.repeat(repeats):

Series.str.replace():

Series.str.rpartition(sep=' ', expand=True):

Series.str.slice(start=None, stop=None, step=None):

Series.str.slice_replace(start=None, stop=None, repl=None):

Series.str.split(pat=None, *, n=-1, expand=False, regex=None):

Series.str.rsplit(pat=None, *, n=-1, expand=False, regex=None):

Series.str.wrap(width, **kwargs):

Series.str.zfill(width):

Series.str.get_dummies(sep='|'):

Встроенные методы в объект `Series.str`

`Series.str.len()`:

`Series.str.cat(others=None, sep=None, na_rep=None, join='left')`:

`Series.str.contains(pat, case=True, flags=0, na=None, regex=True)`:

`Series.str.count(pat, flags=0)`:

`Series.str.extract(pat, flags=0, expand=True)`:

`Series.str.extractall(pat, flags=0)`:

`Series.str.match(pat, case=True, flags=0, na=None)`:

`Series.str.findall(pat, flags=0)`:

`Series.str.fullmatch(pat, case=True, flags=0, na=None)`:

`Series.str.get(i)`:

`Series.str.normalize(form)`:

`Series.str.pad(width, side='left', fillchar=' ')`:

`Series.str.partition(sep=' ', expand=True)`:

`Series.str.removeprefix(prefix)`:

`Series.str.removesuffix(suffix)`:

`Series.str.repeat(repeats)`:

`Series.str.replace()`:

`Series.str.rpartition(sep=' ', expand=True)`:

`Series.str.slice(start=None, stop=None, step=None)`:

`Series.str.slice_replace(start=None, stop=None, repl=None)`:

`Series.str.split(pat=None, , n=-1, expand=False, regex=None)`*:

`Series.str.rsplit(pat=None, , n=-1, expand=False, regex=None)`*:

*`Series.str.wrap(width, **kwargs)`*:

`Series.str.zfill(width)`:

`Series.str.get_dummies(sep='|')`: