Слияние кода завершено, страница обновится автоматически
Перевод текста на русский язык:
Бекон 3 Пастрома 4 Солонина 5 Бекон 6 Пастрома 7 Мраморная ветчина 8 Локс из лосося
Имя: еда, тип: объект
В [57]: данные['животное'] = lowercased.map(мясо_в_животное)
В [58]: данные Выход [58]: еда унции животное 0 бекон 4.0 свинья 1 рваная свинина 3.0 свинка 2 бекон 12.0 свинка 3 пастрома 6.0 корова 4 солонина 7.5 корова 5 бекон 8.0 свинка 6 пастрома 3.0 корова 7 мраморная ветчина 5.0 свинка 8 локс из лосося 6.0 лосось
Мы также можем передать функцию, которая может выполнять всю эту работу:
```python
В [59]: данные ['еда']. карта (лямбда x: мясо_в_животное [x.lower()])
Выход [59]:
0 свинка
1 свинка
2 свинка
3 корова
4 корова
5 свинка
6 корова
7 свинка
8 лосось
Имя: еда, тип: объект
Использование map — это удобный способ для выполнения преобразования элементов и других работ по очистке данных.
Заполнение отсутствующих данных с помощью метода fillna можно рассматривать как особый случай замены значения. Ранее мы уже видели, что map можно использовать для изменения данных подмножества объекта, а replace предоставляет более простой и гибкий способ сделать это. Давайте посмотрим на этот ряд:
В [60]: данные = pd.Series([1., -999., 2., -999., -1000., 3.])
В [61]: данные
Выход [61]:
0 1.0
1 -999.0
2 2.0
3 -999.0
4 -1000.0
5 3.0
-999 может быть маркером для отсутствующих данных. Чтобы заменить его на значение NA, которое может понять pandas, мы можем использовать replace для создания нового ряда (если только не передаётся inplace=True):
В [62]: данные. заменить (-999, np.nan)
Выход [62]:
0 1.0
1 NaN
2 2.0
3 NaN
4 -1000.0
5 3.0
тип: float64
Если вы хотите заменить несколько значений одновременно, вы можете передать список заменяемых значений и одно заменяющее значение:
В [63]: данные. заменить ([-999, -1000], np.nan)
Выход [63]:
0 1.0
1 NaN
2 2.0
3 NaN
4 NaN
5 3.0
тип: float64
Чтобы каждое значение имело разное заменяющее значение, вы можете предоставить список замен:
В [64]: данные. заменить ([-999, -1000], [np.nan, 0])
Выход [64]:
0 1.0
1 NaN
2 2.0
3 NaN
4 0.0
5 3.0
тип: float64
Передаваемые параметры также могут быть словарями:
В [65]: данные. заменить ({-999: np.nan, -1000: 0})
Выход [65]:
0 1.0
1 NaN
2 2.0
3 NaN
4 0.0
5 3.0
тип: float64
Примечание: метод data.replace отличается от метода data.str.replace тем, что последний выполняет замену элементов строки. Мы изучим строковые методы Series позже.
Подобно значениям в Series, метки осей также можно преобразовать с помощью функции или отображения, чтобы получить новый объект с разными метками. Оси также можно изменить на месте, без необходимости создавать новую структуру данных. Рассмотрим следующий простой пример:
В [66]: данные = pd.DataFrame(np.arange(12).reshape((3, 4)),
....: индекс = ['Огайо', 'Колорадо', 'Нью-Йорк'],
....: столбцы = ['один', 'два', 'три', 'четыре'])
Как и в случае с Series, ось имеет метод map:
В [67]: преобразование = лямбда x: x[:4].upper()
В [68]: данные. индекс. карта (преобразование)
Выход [68]: Индекс(['ОГАЙО', 'КОЛОРАДО', 'НЬЮ-ЙОРК'], тип данных: 'объект')
Вы можете присвоить его индексу, чтобы изменить DataFrame на месте:
В [69]: данные. индекс = данные. индекс. карта (преобразование)
В [70]: данные
Выход [70]:
один два три четыре
ОГАЙО 0 1 2 3
КОЛОРАДО 4 5 6 7
НЬЮ-ЙОРК 8 9 10 11
Если вы хотите создать преобразованную версию набора данных (а не изменять исходный набор данных), более практичным методом является rename:
В [71]: данные. переименовать (индекс = str.title, столбцы = str.upper)
Выход [71]:
ОДИН ДВА ТРИ ЧЕТЫРЕ
Индиана 0 1 2 3
Колорадо 4 5 6 7
Нью-Йорк 8 9 10 11
Обратите особое внимание на то, что rename можно комбинировать со словарными объектами для обновления части меток осей:
В [72]: данные. переименовать (index={'Огайо': 'Индиана'},
....: столбцы={'три': 'пикабу'})
Выход [72]:
один два пикабу четыре
Индиана 0 1 2 3
Колорадо 4 5 6 7
Нью-Йорк 8 9 10 11
rename может использоваться для копирования DataFrame и присвоения ему значений индекса и меток столбцов. Если вы хотите изменить существующий набор данных на месте, передайте inplace=True:
В [73]: данные. переименовать (index={'Огайо': 'Индиана'}, inplace=True)
В [74]: данные
Выход [74]:
один два три четыре
Индиана 0 1 2 3
Колорадо 4 5 6 7
Нью-Йорк 8 9 10 11
Для анализа непрерывные данные часто дискретизируются или разбиваются на «бины». Предположим, у вас есть группа данных о людях, и вы хотите разделить их на разные возрастные группы:
В [75]: возрасты = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
Затем эти данные будут разделены на «18–25», «26–35», «35–60» и «60+». Для реализации этой функции вы будете использовать функцию pandas cut:
В [76]: бины = [18, 25, 35, 60, 100]
В [77]: кошки = pd.cut(возрасты, бины)
В [78]: кошки
Выход [78]:
[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (25, 35], (60, 100], (35,60], (35, 60], (25, 35]]
Длина: 12
Категории (4, интервал[int64]): [(18, 25] < (25, 35] < (35, 60] < (60, 100]] ```
cats.codes — это массив, содержащий значения типа int8: [0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1].
cats.categories — это объект IntervalIndex с параметрами:
* closed='right',
* dtype='interval[int64]'.
pd.value_counts(cats) — это подсчёт количества элементов в массиве cats.
Следующую часть текста перевести не удалось, так как она содержит код на языке Python.
group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior'] — это список, состоящий из четырёх элементов.
pd.cut(ages, bins, labels=group_names) — это функция, которая принимает три аргумента: ages, bins и group_names. Она возвращает массив с элементами, соответствующими элементам списка group_names.
Если передать функции cut количество интервалов вместо точных границ интервалов, то она вычислит равные интервалы на основе минимального и максимального значений данных.
qcut — это функция, похожая на cut. Она разделяет данные на интервалы, основываясь на квантилях. В отличие от cut, qcut создаёт интервалы примерно одинакового размера.
В тексте также упоминается функция pd.describe(), которая используется для описания статистических характеристик данных. Однако её описание не приводится.
Также в тексте упоминается функция np.abs(), которая возвращает абсолютное значение числа. Эта функция используется для поиска значений, превышающих заданное число. 544 -3.548824 1.553205 -2.186301 1.277104
635 -0.578093 0.193299 1.397822 3.366626
782 -0.207434 3.525865 0.283070 0.544635
803 -3.645860 0.255475 -0.549574 -1.907459
Согласно этим условиям, можно установить значения. Следующий код позволяет ограничить значения в диапазоне от -3 до 3:
```python
In [97]: data[np.abs(data) > 3] = np.sign(data) * 3
In [98]: data.describe()
Out[98]:
0 1 2 3
count 1000.000000 1000.000000 1000.000000 1000.000000
mean 0.050286 0.025567 -0.001399 -0.051765
std 0.992920 1.004214 0.991414 0.995761
min -3.000000 -3.000000 -3.000000 -3.000000
25% -0.599807 -0.612162 -0.687373 -0.747478
50% 0.047101 -0.013609 -0.022158 -0.088274
75% 0.756646 0.695298 0.699046 0.623331
max 2.653656 3.000000 2.735527 3.000000
В соответствии со знаком данных, np.sign(data) может генерировать 1 и -1:
```python
In [99]: np.sign(data).head()
Out[99]:
0 1 2 3
0 -1.0 1.0 -1.0 1.0
1 1.0 -1.0 1.0 -1.0
2 1.0 1.0 1.0 -1.0
3 -1.0 -1.0 1.0 -1.0
4 -1.0 1.0 -1.0 -1.0
## Перестановка и случайная выборка
Используя numpy.random.permutation функцию, можно легко переставить столбцы Series или DataFrame (переупорядочить случайным образом). Вызывая permutation для оси с нужной длиной, можно получить массив целых чисел, представляющий новый порядок:
```python
In [100]: df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
In [101]: sampler = np.random.permutation(5)
In [102]: sampler
Out[102]: array([3, 1, 4, 2, 0])
Затем этот массив можно использовать в операциях индексации на основе iloc или take:
```python
In [103]: df
Out[103]:
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15
4 16 17 18 19
In [104]: df.take(sampler)
Out[104]:
0 1 2 3
3 12 13 14 15
1 4 5 6 7
4 16 17 18 19
2 8 9 10 11
0 0 1 2 3
Если вы не хотите заменять данные при выборе случайного подмножества, вы можете использовать метод sample на Series и DataFrame:
```python
In [105]: df.sample(n=3)
Out[105]:
0 1 2 3
3 12 13 14 15
4 16 17 18 19
2 8 9 10 11
Чтобы создать выборку (с возможностью повторения), передайте replace=True в sample:
```python
In [106]: choices = pd.Series([5, 7, -1, 6, 4])
In [107]: draws = choices.sample(n=10, replace=True)
In [108]: draws
Out[108]:
4 4
1 7
4 4
2 -1
0 5
3 6
1 7
4 4
0 5
4 4
dtype: int64
## Расчет показателей/фиктивных переменных
Другой распространенный способ преобразования данных в статистике и машинном обучении — это преобразование категориальных переменных в «фиктивные переменные» или «матрицу индикаторов».
Если в столбце DataFrame содержится k различных значений, то можно создать k столбцов матрицы или DataFrame (все значения равны 1 или 0). В pandas есть функция get_dummies, которая выполняет эту задачу (хотя ее можно реализовать самостоятельно):
```python
In [109]: df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
.....: 'data1': range(6)})
In [110]: pd.get_dummies(df['key'])
Out[110]:
a b c
0 0 1 0
1 0 1 0
2 1 0 0
3 0 0 1
4 1 0 0
5 0 1 0
Иногда вы можете захотеть добавить префикс к столбцам фиктивной переменной DataFrame, чтобы их можно было объединить с другими данными. Параметр prefix функции get_dummies позволяет это сделать:
```python
In [111]: dummies = pd.get_dummies(df['key'], prefix='key')
In [112]: df_with_dummy = df[['data1']].join(dummies)
In [113]: df_with_dummy
Out[113]:
data1 key_a key_b key_c
0 0 0 1 0
1 1 0 1 0
2 2 1 0 0
3 3 0 0 1
4 4 1 0 0
5 5 0 1 0
Если строка DataFrame принадлежит нескольким категориям, ситуация становится немного сложнее. Рассмотрим данные MovieLens 1M, которые будут более подробно изучены в главе 14:
```python
In [114]: mnames = ['movie_id', 'title', 'genres']
In [115]: movies = pd.read_table('datasets/movielens/movies.dat', sep='::',
.....: header=None, names=mnames)
In [116]: movies[:10]
Out[116]:
movie_id title genres
0 1 Toy Story (1995) Animation|Children's|Comedy
1 2 Jumanji (1995) Adventure|Children's|Fantasy
2 3 Grumpier Old Men (1995) Comedy|Romance
3 4 Waiting to Exhale (1995) Comedy|Drama
4 5 Father of the Bride Part II (1995) Comedy
5 6 Heat (1995) Action|Crime|Thriller
6 7 Sabrina (1995) Comedy|Romance
7 8 Tom and Huck (1995) Adventure|Children's
8 9 Sudden Death (1995) Нужно перевести данный текст на русский язык?
Вот перевод текста:
**Действие**
9 10 GoldenEye (1995) Action|Adventure|Thriller
Для того чтобы добавить индикаторы переменных для каждого жанра, необходимо выполнить некоторые операции по упорядочиванию данных. Сначала мы извлекаем различные значения жанров из набора данных:
In [117]: all_genres = []
In [118]: for x in movies.genres:
.....: all_genres.extend(x.split('|'))
In [119]: genres = pd.unique(all_genres)
Теперь у нас есть:
In [120]: genres
Out[120]:
array(['Animation', "Children's", 'Comedy', 'Adventure', 'Fantasy',
'Romance', 'Drama', 'Action', 'Crime', 'Thriller','Horror',
'Sci-Fi', 'Documentary', 'War', 'Musical', 'Mystery', 'Film-Noir',
'Western'], dtype=object)
Один из методов построения DataFrame индикаторов заключается в том, чтобы начать с полностью нулевого DataFrame:
In [121]: zero_matrix = np.zeros((len(movies), len(genres)))
In [122]: dummies = pd.DataFrame(zero_matrix, columns=genres)
Сейчас мы итерируем по каждой части фильма и устанавливаем значение 1 для каждой строки в dummies. Для этого мы используем dummies.columns для вычисления индекса каждого типа столбца:
In [123]: gen = movies.genres[0]
In [124]: gen.split('|')
Out[124]: ['Animation', "Children's", 'Comedy']
In [125]: dummies.columns.get_indexer(gen.split('|'))
Out[125]: array([0, 1, 2])
Затем, согласно индексу, мы используем .iloc для установки значений:
In [126]: for i, gen in enumerate(movies.genres):
.....: indices = dummies.columns.get_indexer(gen.split('|'))
.....: dummies.iloc[i, indices] = 1
.....:
После этого мы объединяем его с movies снова:
In [127]: movies_windic = movies.join(dummies.add_prefix('Genre_'))
In [128]: movies_windic.iloc[0]
Out[128]:
movie_id 1
title Toy Story (1995)
genres Animation|Children's|Comedy
Genre_Animation 1
Genre_Children's 1
Genre_Comedy 1
Genre_Adventure 0
Genre_Fantasy 0
Genre_Romance 0
Genre_Drama 0
...
Genre_Crime 0
Genre_Thriller 0
Genre_Horror 0
Genre_Sci-Fi 0
Genre_Documentary 0
Genre_War 0
Genre_Musical 0
Genre_Mystery 0
Genre_Film-Noir 0
Genre_Western 0
Name: 0, Length: 21, dtype: object
Примечание: для больших объёмов данных построение многоэлементных индикаторных переменных может стать очень медленным. Лучше использовать более низкоуровневые функции, записывать их в NumPy массив, а затем упаковывать результат в DataFrame.
Одна полезная хитрость для статистических приложений — это объединение get_dummies и таких дискретных функций, как cut:
In [129]: np.random.seed(12345)
In [130]: values = np.random.rand(10)
In [131]: values
Out[131]:
array([ 0.9296, 0.3164, 0.1839, 0.2046, 0.5677, 0.5955, 0.9645,
0.6532, 0.7489, 0.6536])
In [132]: bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
In [133]: pd.get_dummies(pd.cut(values, bins))
Out[133]:
(0.0, 0.2] (0.2, 0.4] (0.4, 0.6] (0.6, 0.8] (0.8, 1.0]
0 0 0 0 0 1
1 0 1 0 0 0
2 1 0 0 0 0
3 0 1 0 0 0
4 0 0 1 0 0
5 0 0 1 0 0
6 0 0 0 0 1
7 0 0 0 1 0
8 0 0 0 1 0
9 0 0 0 1 0
Мы использовали numpy.random.seed, чтобы сделать этот пример детерминированным. В последующих главах книги будет обсуждаться pandas.get_dummies.
Python может стать популярным языком обработки данных, отчасти благодаря своим простым и удобным функциям обработки строк и текста. Большинство текстовых операций были реализованы в виде встроенных методов строковых объектов. Более сложные шаблоны сопоставления и текстовые операции могут потребовать использования регулярных выражений. Pandas предоставляет дополнительные возможности, позволяя применять строковые выражения и регулярные выражения к целым группам данных и обрабатывать надоедливые пропущенные данные.
Многие задачи обработки и сценариев, связанных со строками, можно решить с помощью встроенных методов строк. Например, строку, разделённую запятыми, можно разделить на несколько частей с помощью метода split:
In [134]: val = 'a,b, guido'
In [135]: val.split(',')
Out[135]: ['a', 'b', ' guido']
split часто используется вместе с методом strip для удаления пробелов (включая символы новой строки):
In [136]: pieces = [x.strip() for x in val.split(',')]
In [137]:
``` Текст запроса написан на языке Python.
Перевод текста запроса:
**Использование Python для работы со строками**
С помощью сложения можно соединить подстроки, разделённые двоеточием, в одну строку:
first, second, third = pieces first + '::' + second + '::' + third
Но этот способ не очень удобен. Более быстрый и соответствующий стилю Python способ — передать методу join строки «::» список или кортеж:
'::'.join(pieces)
Другие методы связаны с поиском подстрок. Лучший способ проверить наличие подстроки — использовать ключевое слово in в Python, а также методы index и find:
val.index(',') val.find(':')
Обратите внимание на разницу между методами find и index: если подстрока не найдена, метод index вызовет исключение (а не вернёт -1):
val.index(':') ValueError: substring not found
Метод count возвращает количество вхождений подстроки:
val.count(',')
Метод replace используется для замены одного шаблона другим. Передавая пустую строку, его часто используют для удаления шаблона:
val.replace(',', '::') val.replace(',', '')
Таблица 7-3 содержит список встроенных методов строк Python.
Большинство этих операций можно выполнить с помощью регулярных выражений (которые скоро будут рассмотрены).
**Регулярные выражения**
Регулярные выражения предоставляют гибкий способ поиска или сопоставления строк по шаблону в тексте. Регулярные выражения, также известные как regex, представляют собой строки, написанные на языке регулярных выражений. Встроенный модуль Python re отвечает за применение регулярных выражений к строкам. Я приведу несколько примеров их использования.
>Примечание: написание регулярных выражений может стать темой отдельной главы, выходящей за рамки этой книги. В интернете и других книгах можно найти множество отличных руководств и справочных материалов.
Функции модуля re можно разделить на три категории: сопоставление с образцом, замена и разделение. Конечно, они взаимосвязаны. Regex описывает шаблон, который необходимо найти в тексте, и может использоваться для различных целей. Давайте сначала рассмотрим простой пример: предположим, я хочу разделить строку, используя в качестве разделителя любое количество пробелов (табуляция, пробелы, перевод строки и т. д.). Регулярное выражение для описания любого количества пробелов — \s+:
import re text = "foo bar\t baz \tqux" re.split('\s+', text)
При вызове функции re.split('\s+, text) регулярное выражение сначала компилируется, а затем вызывается метод split для text. Вы можете скомпилировать регулярное выражение самостоятельно с помощью функции re.compile, чтобы получить повторно используемый объект регулярного выражения:
regex = re.compile('\s+') regex.split(text)
Если вы хотите получить все совпадения регулярного выражения, вы можете использовать метод findall:
regex.findall(text)
>Примечание: если вы хотите избежать ненужных escape-символов в регулярных выражениях (\), вы можете использовать необработанные строки, такие как r'C:\x' (или эквивалент 'C:\\x').
Если вам нужно применить одно и то же регулярное выражение ко многим строкам, рекомендуется создать объект регулярного выражения с помощью re.compile. Это может сэкономить значительное количество процессорного времени.
Методы match и search похожи на findall. Findall возвращает все совпадения в строке, а search — только первое совпадение. Метод match более строгий, он соответствует только началу строки. Рассмотрим небольшой пример: у нас есть текст и регулярное выражение, которое может распознавать большинство адресов электронной почты:
text = """Dave dave@google.com Steve steve@gmail.com Rob rob@gmail.com Ryan ryan@yahoo.com""" pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+.[A-Z]{2,4}'
Применение метода findall к тексту даст нам список адресов электронной почты:
regex.findall(text)
search возвращает первый адрес электронной почты из текста (в виде специального объекта совпадения):
m = regex.search(text) m
Для этого регулярного выражения объект совпадения может сказать нам только начальную и конечную позиции шаблона в исходной строке:
text[m.start():m.end()]
метод match вернёт None, поскольку он соответствует только шаблонам, начинающимся с начала строки:
print(regex.match(text))
Соответственно, метод sub может заменить совпадающие шаблоны указанной строкой и вернуть полученную новую строку:
print(regex.sub('REDACTED', text))
Предположим, что вы не только хотите найти адреса электронной почты, но и разделить каждый адрес на три части: имя пользователя, домен и суффикс домена. Чтобы реализовать эту функцию, просто заключите части шаблона, которые вы хотите разделить, в круглые скобки:
pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+).([A-Z]{2,4})' regex = re.compile(pattern, flags=re.IGNORECASE)
Модифицированное регулярное выражение создаёт объекты совпадения, которые могут возвращать кортеж, содержащий различные части шаблона, через свой метод groups:
m = regex.match('wesm@bright.net') m.groups()
Для регулярных выражений с группами метод findall вернёт список кортежей:
regex.findall(text)
Подстановка также может обращаться к различным группам в шаблоне с помощью таких специальных символов, как \1, \2 и так далее:
regex.sub(r'Username: \1, Domain: \2, Suffix: \3', text) Перевод текста на русский язык:
Имя пользователя: Стив, домен: gmail, суффикс: com. Имя пользователя: Роб, домен: gmail, суффикс: com. Имя пользователя: Райан, домен: yahoo, суффикс: com.
В Python существует множество регулярных выражений, но большинство из них выходит за рамки этой книги. Таблица 7-4 представляет собой краткое резюме.
pandas векторизованные строковые функции
При очистке беспорядочных данных для анализа часто требуется выполнить некоторую работу по упорядочиванию строк. Более сложная ситуация заключается в том, что столбцы, содержащие строки, иногда также содержат пропущенные данные:
In [167]: data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com',
.....: 'Rob': 'rob@gmail.com', 'Wes': np.nan}
In [168]: data = pd.Series(data)
In [169]: data
Out[169]:
Dave dave@google.com
Rob rob@gmail.com
Steve steve@gmail.com
Wes NaN
dtype: object
In [170]: data.isnull()
Out[170]:
Dave False
Rob False
Steve False
Wes True
dtype: bool
С помощью data.map все строки и регулярные выражения могут быть применены к каждому значению (передавая lambda-выражение или другую функцию), но если есть NA (null), будет выдана ошибка. Чтобы решить эту проблему, Series имеет несколько методов, ориентированных на массивы, которые могут пропускать значения NA при выполнении операций со строками. Эти методы доступны через атрибут str Series. Например, мы можем использовать str.contains для проверки того, содержит ли каждый адрес электронной почты «gmail»:
In [171]: data.str.contains('gmail')
Out[171]:
Dave False
Rob True
Steve True
Wes NaN
dtype: object
Также можно использовать регулярные выражения и добавить любые параметры re (например, IGNORECASE):
In [172]: pattern
Out[172]: '([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\\.([A-Z]{2,4})'
In [173]: data.str.findall(pattern, flags=re.IGNORECASE)
Out[173]:
Dave [(dave, google, com)]
Rob [(rob, gmail, com)]
Steve [(steve, gmail, com)]
Wes NaN
dtype: object
Есть два способа реализовать векторизованное получение элементов: либо использовать str.get, либо использовать индексацию на атрибуте str:
In [174]: matches = data.str.match(pattern, flags=re.IGNORECASE)
In [175]: matches
Out[175]:
Dave True
Rob True
Steve True
Wes NaN
dtype: object
Чтобы получить доступ к элементам вложенного списка, мы можем передать индекс этим двум функциям:
In [176]: matches.str.get(1)
Out[176]:
Dave NaN
Rob NaN
Steve NaN
Wes NaN
dtype: float64
In [177]: matches.str[0]
Out[177]:
Dave NaN
Rob NaN
Steve NaN
Wes NaN
dtype: float64
Этот метод можно использовать для извлечения подстрок:
In [178]: data.str[:5]
Out[178]:
Dave dave@
Rob rob@g
Steve steve
Wes NaN
dtype: object
Таблица 7–5 описывает больше векторных строковых методов pandas.
Рисунок таблицы 7–5 частично векторизованных строковых методов.
Эффективная подготовка данных позволяет вам тратить больше времени на анализ данных и меньше времени на подготовительную работу, что может значительно повысить производительность. В этой главе мы изучили множество инструментов, но охват не является исчерпывающим. В следующей главе мы изучим агрегацию и группировку pandas.
Вы можете оставить комментарий после Вход в систему
Неприемлемый контент может быть отображен здесь и не будет показан на странице. Вы можете проверить и изменить его с помощью соответствующей функции редактирования.
Если вы подтверждаете, что содержание не содержит непристойной лексики/перенаправления на рекламу/насилия/вульгарной порнографии/нарушений/пиратства/ложного/незначительного или незаконного контента, связанного с национальными законами и предписаниями, вы можете нажать «Отправить» для подачи апелляции, и мы обработаем ее как можно скорее.
Опубликовать ( 0 )