Как сделать из столбца строку pandas

Обновлено: 06.07.2024

но я хочу убедиться, что 303 столбца приведены в виде строк, а не целых чисел, чтобы я получил это:

У меня есть такой фрейм данных pandas: ts | thing_0 | qty_0 | thing_1 | qty_1 | thing_2 | qty_2 -------------------------------------------------------- 1 | dog | 5 | cat | 3 | mouse | 1 2 | house | 6 | dog | 4 | cat | 2 . Я хочу преобразовать это таким образом, чтобы thing s стали столбцами, а.

Я хотел бы преобразовать следующий dataframe в json . df: A sector B sector C sector TTM Ratio -- 35.99 12.70 20.63 14.75 23.06 RRM Sales -- 114.57 1.51 5.02 1.00 4594.13 MQR book 1.48 2.64 1.02 2.46 2.73 2.74 TTR cash -- 14.33 7.41 15.35 8.59 513854.86 Для того чтобы сделать это с помощью функции.

Один из способов преобразования в строку-использовать astype :

Однако, возможно, вы ищете функцию to_json , которая преобразует ключи в действительные json (и, следовательно, ваши ключи в строки):

Примечание: вы можете передать буфер/файл, чтобы сохранить его, а также некоторые другие параметры...

Если вам нужно преобразовать столбцы ALL в строки, вы можете просто использовать:

Это полезно, если вам нужно, чтобы все, кроме нескольких столбцов, было strings/objects,, а затем вернитесь и преобразуйте остальные в то, что вам нужно (в данном случае целое число):

Вот еще один, особенно полезный для преобразования нескольких столбцов в строку , а не только в один столбец:

До pandas 1.0 (ну, на самом деле 0.25) это был способ defacto объявить ряд/столбец как строку:

Начиная с pandas 1.0, рассмотрите возможность использования вместо этого типа "string" .

Вот почему, как цитируют документы:

Вы можете случайно сохранить смесь строк и нестрогих объектов в массиве dtype объекта. Лучше иметь специальный dtype.
object dtype прерывает операции, специфичные для dtype, такие как DataFrame.select_dtypes() . Нет четкого способа выбрать только текст при этом исключаются нетекстовые, но все же объектно-dtype столбцы.
При чтении кода содержимое массива dtype object менее понятно, чем 'string' .

Типы расширений (введенные в 0.24 и формализованные в 1.0) ближе к pandas, чем к numpy, что хорошо, потому что типы numpy недостаточно мощны. Например, NumPy не имеет никакого способа представления отсутствующих данных в целочисленных данных (так как type(NaN) == float )., но pandas может использовать целочисленные столбцы с нулевым значением).

Почему я должен прекратить его использовать?

Случайное смешивание dtypes
Первая причина, описанная в документах, заключается в том, что вы можете случайно хранить нетекстовые данные в Столбцах объектов.

Сложно различать строки и другие объекты python
Другой очевидный пример пример заключается в том, что труднее различить объекты "strings" и "objects"., которые по существу являются общим типом для любого типа, который не поддерживает векторизуемые операции.

До pandas 0.25 не было практически никакого способа отличить, что "A" и "B" не имеют одного и того же типа данных.

С pandas 1.0 это становится намного проще:

Удобочитаемость
Это само собой разумеется ;-)

OK, так я должен прекратить использовать его прямо сейчас?

..На момент написания этого ответа (версия 1.1) никаких преимуществ в производительности нет, но документы ожидают, что будущие усовершенствования значительно улучшат производительность и сократят использование памяти для столбцов "string" в отличие от объектов. С учетом сказанного, однако, никогда не бывает слишком рано, чтобы сформировать хорошие привычки!

Я хочу преобразовать pandas DataFrame из двух столбцов в одну строку: import numpy as np import pandas as pd df_a = pd.DataFrame(< 'Type': ['A', 'B', 'C', 'D', 'E'], 'Values':[2,4,7,9,3]>) df_a Type Values 0 A 2 1 B 4 2 C 7 3 D 9 4 E 3 df_b = df_a.pivot(columns='Type', values='Values') df_b Что.

У меня есть фрейм данных pandas с различными типами данных. Я хочу преобразовать более одного столбца во фрейме данных в строковый тип. Я индивидуально сделал для каждой колонки, но хочу знать, есть ли эффективный способ? Поэтому в настоящее время я делаю что-то вроде этого.

Использование .apply() с функцией преобразования lambda также работает в этом случае:

total_rows['ColumnID'] = total_rows['ColumnID'].apply(lambda x: str(x))

Для целых фреймов данных можно использовать .applymap() . (но в любом случае, вероятно, .astype() быстрее)

Метод to_numaric для сокрытия столбцов до числовых значений в Пандах

Функция to_numeric() является лучшим способом преобразования одного или нескольких столбцов DataFrame в числовые значения. Он также попытается изменить нецифровые объекты (такие как строки) на целые числа или числа с плавающей точкой, как это уместно. to_numeric() вход может быть последовательностью или столбцом DataFrame . Если некоторые значения не могут быть приведены к числовому типу, то функция to_numaric() позволяет заставить не числовые значения быть NaN .

to_numeric() даст нам по умолчанию либо int64 , либо float64 dtype. Мы можем использовать опцию понижения до integer , signed , unsigned , float :

Метод astype() для преобразования одного типа в любой другой

Метод astype() позволяет нам четко указать тип, который мы хотим преобразовать. Мы можем перейти от одного типа данных к другому, передавая параметр внутри метода astype() .

Рассмотрим следующий код:

Метод infer_objects() для приведения типа данных столбцов к более конкретному типу

infer_objects() method introduced from Version 0.21.0 of the pandas for converting columns of a dataFrame to a more specific data type (soft conversions).

Рассмотрим следующий код:

report this ad

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

Вступление

Pandas – библиотека Python с открытым исходным кодом для анализа данных. Она предназначена для эффективной и интуитивной обработки структурированных данных.

В этой статье мы рассматрим наиболее распространенные способы создания DataFrame и методы изменения их структуры.

Мы будем использовать блокнот Jupyter, так как он предлагает хорошее визуальное представление DataFrames. Однако любая среда IDE также выполнит эту работу, просто вызвав инструкцию print() для объекта DataFrame.

Создание DataFrame

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

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

Любое несоответствие приведет к тому, что DataFrame будет неисправен, что приведет к ошибкам.

Создание пустого DataFrame

Создать пустой DataFrame так же просто, как:

Рассмотрим, как можно добавлять строки и столбцы в этот пустой DataFrame при управлении их структурой.

Создание DataFrame из списков

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

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

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

Что даёт нам тот же результат, что и раньше, только с более значимыми именами столбцов:

Другим представлением данных, которое можно использовать здесь, является предоставление данных в виде списка словарей в следующем формате:

В нашем примере представление будет выглядеть следующим образом:

И мы создадим DataFrame таким же образом, как и раньше:

Создание DataFrame из словарей

Словари являются еще одним способом предоставления данных в виде столбцов. Каждому столбцу присваивается упорядоченный список строк значений.

Давайте представим те же данные, что и раньше, но в формате словаря:

Что дает нам ожидаемый результат:

Чтение DataFrame из файла

Для чтения и записи DataFrames поддерживается множество типов файлов. Каждая функция соответствует типу файла, например read_csv(), read_excel(), read_json(), read_html() и т.д.

Наиболее распространенным типом файла является .csv (значения разделенные запятыми). Строки состоят из значений, разделенных специальным символом (чаще всего запятой). Можно задать другой разделитель с помощью аргумента sep.

Если вы не знакомы с типом файла .csv , вот пример того, как он выглядит:

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

Что дает нам на выходе:

Манипулирование Фреймами Данных

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

Доступ/Расположение Элементов

Pandas имеет два разных способа выбора данных – loc[] и iloc[].

loc[] позволяет выбирать строки и столбцы с помощью меток, таких как row[‘Value’] и culumn[‘Other Value’]. В то же время, iloc[] принимает индекс записей, которые вы хотите выбрать, поэтому вы можете использовать только числа. Можно также выбрать столбцы, просто передав их имя в скобки. Посмотрим, как это работает в действии:

Это также работает для группы строк, от 0 до n:

Важно отметить, что iloc[] всегда ожидает целое число. loc[] поддерживает и другие типы данных. Здесь мы также можем использовать целое число на ряду с другими типами данных, например строки.

Также можно получить доступ к определенным значениям для элементов. Например, может потребоваться получить доступ к элементу во 2-й строке, но вернуть только его значение Name:

Доступ к столбцам так же прост, как запись dataFrameName.ColumnName или dataFrameName [‘ColumnName’]. Второй вариант предпочтителен, так как столбец может иметь то же имя, что и зарезервированное имя в Pandas, и использование первого варианта в этом случае может вызвать ошибки:

Доступ к столбцам можно также получить с помощью loc[] и iloc[]. Например, мы получим доступ ко всем строкам, начиная с 0…n, где n – количество строк, и выберем первый столбец. Вывод совпадает с выводом предыдущей строки кода:

Манипулирование Индексами

Индексы – это метки строк в DataFrame и именно их мы используем при обращении к строкам. Поскольку мы не изменили индексы по умолчанию, которые Pandas присваивают DataFrame при создании, все наши строки были помечены целыми числами от 0 и выше.

Первый способ изменить индексацию вашего DataFrame – это использовать метод set_index() . Мы передаем любой из столбцов в вашем DataFrame этому методу, и он становится новым индексом. Таким образом, мы можем либо сами создавать индексы, либо просто назначить столбец в качестве индекса.

Обратите внимание, что метод не изменяет исходный DataFrame, а вместо этого возвращает новый DataFrame с новым индексом, поэтому мы должны назначить возвращаемое значение переменной DataFrame, если мы хотим сохранить изменение, или установить флаг inplace равным True:

Это будет работать так же хорошо:

Теперь, когда у нас есть нестандартный индекс, мы можем использовать новый набор значений, используя reindex(), Pandas автоматически заполнит значения NaN для каждого индекса, который не может быть сопоставлен с существующей строкой:

Вы можете контролировать, какое значение Pandas использует для заполнения пропущенных значений, установив необязательный параметр fill_value :

Поскольку мы установили новый индекс для нашего DataFrame, loc[] теперь работает с этим индексом:

Манипулирование строками (rows)

Добавление и удаление строк становится простым, если удобно использовать loc[]. Если задать несуществующую строку, она будет создана:

И если вы хотите удалить строку, вы указываете ее индекс функции drop () . Он принимает необязательный параметр axis . Ось | принимает 0 / индекс или 1 / колонки . В зависимости от этого функция drop() отбрасывает либо вызываемую строку, либо вызываемый столбец.

Если требуется удалить строку, необходимо указать ее индекс для функции drop(). Она принимает необязательный параметр, axis. Axis может быть 0/index или 1/columns. В зависимости от этого функция drop() удаляет строку или столбец для которого она была вызвана.

Если не указать значение параметра axis , то соответствующая строка будет удалена по умолчанию, так как axis 0 по умолчанию:

Если не указать значение параметра axis, соответствующая строка будет удалена по умолчанию, так как axis по умолчанию равен 0:

Вы также можете переименовать строки, которые уже существуют в таблице. Функция rename() принимает словарь изменений, которые вы хотите внести:

Обратите внимание, что drop() и rename() также принимают необязательный параметр inplace . Установка этого параметра в True ( False по умолчанию) скажет Pandas изменить исходный DataFrame вместо того, чтобы возвращать новый. Если оставить его не заданным, вам придется упаковать полученный DataFrame в новый, чтобы сохранить изменения.

Другим полезным методом, о котором следует знать, является функция drop_duplicates(), которая удаляет все повторяющиеся строки из DataFrame. Давайте продемонстрируем это, добавив две повторяющиеся строки:

Что дает нам выход:

Теперь мы можем вызвать drop_duplicates() :

И дубликаты строк будут удалены:

Манипулирование столбцами (columns)

Новые столбцы можно добавлять аналогично добавлению строк:

Также, как и строки, столбцы можно удалить, вызвав функцию drop() , с той лишь разницей, что вы должны установить необязательный параметр axis в значение 1 чтобы Pandas знали, что вы хотите удалить столбец, а не строку:

Когда речь идет о переименовании столбцов, функции rename() нужно сказать конкретно, что мы хотим изменить столбцы, установив необязательные параметр columns значение нашего “словаря изменений”:

Опять же, как и при удалении/переименовании строк, вы можете установить необязательный параметр на месте в True если вы хотите, чтобы исходный DataFrame был изменен вместо функции, возвращающей новый DataFrame .

Опять же, как и при удалении/переименовании строк, можно установить для параметра inplace значение True, если требуется изменить исходный DataFrame вместо создания нового DataFrame.

Вывод

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

В этой статье мы рассмотрели, что такое Pandas DataFrame, поскольку он является ключевым классом фреймворка Pandas для хранения данных.

Мы научились создавать DataFrame вручную, используя список и словарь, после чего считывали данные из файла.

Затем мы манипулировали данными в DataFrame – используя loc[] и iloc[] , мы находили данные, создавали новые строки и столбцы, переименовывали существующие и затем удаляли их.

Затем мы манипулировали данными в DataFrame используя loc[] и iloc[]. Мы обнаружили данные, создали новые строки и столбцы, переименовали существующие, а затем удалили их.

Все знают эту команду. Но когда данные, которые вы пытаетесь обработать, большие, попробуйте добавить аргумент nrows = 5, чтобы прочитать только крошечную часть таблицы перед фактической загрузкой всей таблицы. Зачем? Так удастся избежать ошибки с выбором неправильного разделителя, ведь это не всегда запятая.

Или используйте head в Linux, чтобы вывести первые, скажем, 5 строк из любого текстового файла: head –n 5 data.txt.

Извлеките список столбцов с df.columns.tolist() . Добавьте аргумент usecols = ['c1', 'c2',…], чтобы загрузить только необходимые столбцы. Кроме того, если знаете типы данных нескольких конкретных столбцов, добавьте аргумент dtype = . Так загрузка будет быстрее. Этот аргумент даёт ещё одно преимущество. Если один столбец содержит строки и числа, рекомендуется объявить его тип строковым. Так вы избежите ошибок при объединении таблиц, когда используете этот столбец как ключ.

Если нужна предварительная обработка данных на языке Python, то эта команда сэкономит вам время. После чтения из таблицы типами данных по умолчанию для каждого столбца будут bool, int64, float64, object, category, timedelta64 или datetime64. Можете сначала проверить распределение с помощью

чтобы узнать все типы данных объекта DataFrame. Далее выполните

df.select_dtypes(include = ['float64', 'int64'])

чтобы выбрать подмножество объекта DataFrame только с числовыми характеристиками.

Это важная команда, если ещё не слышали о ней. Когда выполните следующие операции

трансформация true, false в 1, 0 для моделирования;
определение уровней;
установленные пользователем кодировки.

Нужен новый столбец с несколькими другими столбцами в качестве входных данных? Функция apply спешит на помощь!

Здесь определена функцию с двумя входными переменными, и с помощью функции apply применяем к столбцам 'c1' и 'c2'.

но это будет намного медленнее, чем

Вывод: не используйте apply, если можете выполнить ту же работу с помощью других встроенных функций, которые часто работают быстрее. Например, если нужно округлить столбец 'c' до целых чисел, выполните round(df['c'], 0) или df['c'].round(0) вместо apply: df.apply(lambda x: round(x['c'], 0), axis = 1) .

Команда для проверки распределения значений. Чтобы проверить возможные значения и частоту каждого отдельного значения в столбце 'c', выполните:

Некоторые полезные трюки и аргументы этой функции:

normalize = True – проверить частоту вместо подсчёта.
dropna = False – включить пропущенные значения в статистику.
df['c'].value_counts().reset_index() – преобразовать таблицу статистики в объект Pandas DataFrame.
df['c'].value_counts().reset_index().sort_values(by='index') – показывать статистику, отсортированную по уникальным значениям в столбце 'c' вместо количества.

При построении моделей часто надо исключить строку с большим количеством пропущенных значений или строки со всеми пропущенными значениями. Используйте .isnull() и .sum() для подсчёта количества пропущенных значений в указанных столбцах:

У нас есть числовой столбец. Хотим классифицировать значения в этом столбце по группам:

верхние 5% в группе 1
5–20% в группе 2
20–50% в группе 3
нижние 50% в группе 4

Конечно, можно сделать это с помощью pandas.cut, но рассмотрим другой вариант

который быстро запускается, потому что не применяется функция apply.

Опять же, это команда, которую все будут использовать. Здесь расскажем о двух трюках. Первый:

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

Ещё один трюк касается смешения целых чисел и пропущенных значений. Если столбец содержит как пропущенные значения, так и целые числа, типом данных по-прежнему будет float, а не int. Когда экспортируете таблицу, добавьте float_format = '%. 0f', чтобы округлить числа с плавающей точкой до целых чисел. Используйте этот трюк, когда нужны только целочисленные выходные данные столбцов – так избавитесь от надоедливых '.0'.

Это перевод статьи о трюках библиотеки Python Pandas на Towards Data Science.

Читайте также: