Как найти пропуски в dataframe pandas

Отсутствующее значение в наборе данных отображается как вопросительный знак, ноль, NaN или просто пустая ячейка. Но как можно справиться с недостающими данными?

Конечно, каждая ситуация отличается и должна оцениваться по-разному.

Есть много способов справиться с недостающими значениями. Рассмотрим типичные варианты на примере набора данных — ‘Titanic’. Эти данные являются открытым набором данных Kaggle.

Для анализа необходимо импортировать библиотеки Python и загрузить данные.

Для загрузки используется метод Pandas read.csv(). В скобках указывается путь к файлу в кавычках, чтобы Pandas считывал файл во фрейм данных (Dataframes — df) с этого адреса. Путь к файлу может быть URL адрес или вашим локальным адресом файла.

# import the libraries
import pandas as pd
import numpy as np

import matplotlib.pyplot as plt
import seaborn as sns

%matplotlib inline
import matplotlib as plt
import matplotlib as mpl
import matplotlib.cm as cm 
import matplotlib.pyplot as plt
from matplotlib import pyplot

# import the dataset
train_df = pd.read_csv(r'C:UsersTatianaDesktopPythontitanictrain.csv')
train_df.head(2)

Посмотрим на размер данных (количество строк, колонок):

train_df.shape

(891, 12)

Для просмотра статистической сводки каждого столбца, чтобы узнать распределение данных в каждом столбце используется метод describe( ). Этот метод показывает нам количество строк в столбце — count, среднее значение столбца — mean, столбец стандартное отклонение — std, минимальные (min) и максимальные (max) значения, а также границу каждого квартиля — 25%, 50% и 75%. Любые значения NaN автоматически пропускаются.

train_df.describe()

По умолчанию, метод describe( ) пропускает строки и столбцы не содержащие чисел — категориальные признаки. Чтобы включить сводку по всем столбцам нужно в скобках добавить аргумент — include = «all».

# describe all the columns
train_df.describe(include = "all")

Для категориальных признаков этот метод показывает: — Сколько уникальных значений в наборе данных — unique; top значения; частота появления значений — freg.

Метод info( ) — показывает информацию о наборе данных, индекс, столбцы и тип данных, ненулевые значения и использование памяти.

# look at the info
print(train_df.info())

В результате мы видим, что все колонки, кроме колонок ‘Age’, ‘Cabin’ и ‘Embarked’, содержат по 891 строк.

Колонка ‘Survived’ — это целевое значение. Показывает, кто выжил, а кто — нет. Эта колонка заполнена бинарными значениями:

0 — не выжил

1 — выжил

Метод — value_counts(). Подсчет значений — это хороший способ понять, сколько единиц каждой характеристики / переменной у нас есть.

train_df['Survived'].value_counts()

Из 891 пассажира выжило 342.

sns.set_style('whitegrid')
sns.countplot(x='Survived',data=train_df,palette='RdBu_r')

Из 891 пассажира выжило 342 это 38%.

figure, survive_bar = plt.subplots(figsize=(7, 7))
sns.barplot(x= train_df["Survived"].value_counts().index, y = train_df["Survived"].value_counts(), ax = survive_bar)
survive_bar.set_xticklabels(['Not Survived', 'Survived'])
survive_bar.set_ylabel('Frequency Count')
survive_bar.set_title('Count of Survival', fontsize = 16)

for patch in survive_bar.patches:
    label_x = patch.get_x() + patch.get_width()/2  # find midpoint of rectangle
    label_y = patch.get_y() + patch.get_height()/2
    survive_bar.text(label_x, label_y,
                #left - freq below - rel freq wrt population as a percentage
               str(int(patch.get_height())) + '(' +
               '{:.0%}'.format(patch.get_height()/len(train_df.Survived))+')',
               horizontalalignment='center', verticalalignment='center')

Визуализация: Графики подсчета значений в колонках — «Survived», «Pclass», «Sex», «SibSp», «Parch», «Embarked»

fig, myplot = plt.subplots(figsize = (15,6), nrows = 2,ncols = 3)

features = ["Survived","Pclass","Sex","SibSp","Parch","Embarked"]

row, col, num_cols = 0,0,3

for u in features:
    sns.barplot(x = train_df[u].value_counts().index,y = train_df[u].value_counts(),
                ax  = myplot[row, col])
    myplot[row, col].set_xlabel("")
    myplot[row, col].set_title(u + " Titanic", fontsize = 15)
    myplot[row, col].set_ylabel("Count")
    col = col + 1
    if col == 3:
        col = 0
        row = row + 1

plt.subplots_adjust(hspace = 0.5)
plt.subplots_adjust(wspace = 0.3)
# i put roundbracket around x,y,z to make more sense. just like how x in [1,2,3] 
# and if x is a tuple or bracket
#we have   u in [(1,2,3),(2,3,5),...] where u = (x,y,z)

#for each patch in each graph from [0,0] to [1,2], we want to do the following...
for v in range(2):
    for z in range(3):
        for patch in myplot[v,z].patches:
            label_x = patch.get_x() + patch.get_width()/2  # find midpoint of rectangle
            label_y = patch.get_y() + patch.get_height()/2
            myplot[v,z].text(label_x, label_y, 
                             str(int(patch.get_height())) + '('+'{:.0%}'.format(
                               patch.get_height()/len(train_df.Survived))+')',
                            horizontalalignment='center', verticalalignment='center')

Теперь посмотрим на колонки которые имеют пропущенные значения.

Есть два метода обнаружения недостающих данных: — isnull() и notnull().

Результатом является логическое значение, указывающее, действительно ли значение, переданное в аргумент, отсутствует. «Истина» ( True ) означает, что значение является отсутствующим значением, а «Ложь» ( False ) означает, что значение не является отсутствующим.

# Evaluating for Missing Data
missing_data = train_df.isnull()
missing_data.head(6)

Используя цикл for в Python, мы можем быстро определить количество пропущенных значений в каждом столбце. Как упоминалось выше, «Истина» представляет отсутствующее значение, а «Ложь» означает, что значение присутствует в наборе данных. В теле цикла for метод «.value_counts ()» подсчитывает количество значений «True».

# Count missing values in each column
for column in missing_data.columns.values.tolist():
    print(column)
    print(missing_data[column].value_counts())
    print(" ")

Посмотрим — сколько пропущенных значений в каждой колонке.

train_df.isnull().sum()

‘Age’

В колонке возраст — ‘Age’ не указано 177 значений. И нужно понять — это систематическая ошибка или какая-то случайная погрешность.

Н-р, может у пассажиров 1 класса (или у женщин) не спрашивали про возраст ( т. к. это было не прилично), или случайно пропустили. Понимание о причине пропущенных значений, определит — как работать с этими отсутствующими данными.

Нужно сгруппировать возраст, относительно того, отсутствует возраст или нет. Для группировки используем метод groupby().

True — отсутствует возраст

False — значение заполнено

# missing age or not
train_df.groupby(train_df['Age'].isnull()).mean()

Среди пассажиров, у которых значение возраста отсутствовало, были выжившие (около 30%) и погибшие (около 70%) — колонка ‘Survived’, True = 0.29 .

Эти пассажиры были в более низком классе:

• колонка ‘Pclass’ — True = 2.59 (это среднее значение класса)

• колонка ‘Fare’ — True = 22.15 (это среднее значение стоимости билета)

Подсчет значений в колонке ‘Pclass’:

# Value Counts
train_df['Pclass'].value_counts()

Например, в 3 классе было 491 пассажира (это 55%)

train_df.groupby(['Pclass']) ['Survived'].value_counts(normalize=True)

Для более детального анализа, создадим новую колонку ‘Age_NaN’ (бинарный классификатор). Используем метод where(), где прописываем условие: — если значение в колонке ‘Age’ отсутствует, то присваиваем в колонке ‘Age_NaN’ — значение 0, если присутствует, то 1.

# Let's create a new column 'Age_NaN'
# If there is no value in the "Age" column, then = 0 and yes value = 1
train_df['Age_NaN'] = np.where(train_df['Age'].isnull(), 0,1)
train_df.head(6)

Подсчет значений в колонке ‘Age_NaN’

# Value Counts
train_df['Age_NaN'].value_counts()

Выживаемость пассажиров в зависимости от наличия записи о возрасте.

# Survived passengers by 'Age_NaN'
train_df.groupby(['Age_NaN']) ['Survived'].value_counts(normalize=True)

И снова мы видим: — что, среди пассажиров, у которых значение возраста отсутствовало, были выжившие (около 30%) и погибшие (около 70%).

Выживаемость пассажиров в зависимости от наличия записи о возрасте и класса.

train_df.groupby(['Age_NaN','Pclass']) ['Survived'].value_counts(normalize=True)

pd.crosstab(train_df['Pclass'], train_df['Age_NaN'])

В первом классе запись отсутствует у 30 пассажиров. Из 30 пассажиров выжило — 46%(14 пассажиров), погибло — 53%(16 пассажиров). Всего пассажиров было в первом классе — 216 (в данном наборе данных).

Во втором классе запись отсутствует у 11 пассажиров. Из 11 пассажиров выжило — 36%(4 пассажира), погибло — 63% (7 пассажиров). Всего пассажиров было во втором классе — 184 (в данном наборе данных).

В третьем классе запись отсутствует у 136 пассажиров. Из 136 пассажиров выжило — 25% (34 пассажира), погибло — 75% (102 пассажира). Всего пассажиров было в третьем классе — 491 (в данном наборе данных).

Выживаемость пассажиров в зависимости от наличия записи о возрасте и пола.

train_df.groupby(['Age_NaN','Sex']) ['Survived'].value_counts(normalize=True)

pd.crosstab(train_df['Sex'], train_df['Age_NaN'])

У 53 женщин нет записи о возрасте. Из 53 женщин выжило 68% (36 женщин), погибло 32% (17 женщин). Всего женщин было — 314 (в данном наборе данных).

У 124 мужчин нет записи о возрасте. Из 124 мужчин выжило 13% (16 мужчин), погибло 87% (108 мужчин). Всего мужчин было — 577 (в данном наборе данных)

Пассажиров было много в 3 классе и много погибло. Пассажиры — мужчины, у которых был более дешевый билет и более низкий класс — имели меньше шансов выжить.

Т.к. среди пассажиров, у которых значение возраста отсутствовало, были выжившие (около 30%) и погибшие (около 70%), и пассажиры были с разных классов( из 3 класса было значительно больше), и среди пассажиров были мужчины и женщины (мужчин было значительно больше), то при опросе у выживших и при осмотре тел погибших могли случайно пропустить возраст пассажира.

Следовательно делаем вывод, что возраст случайно не занесли.

Решение: Пропущенные значения заполнить средним значением.

# missing values are replaced by the average value
train_df['Age'].fillna(train_df['Age'].mean(), inplace = True)

sns.set_style('whitegrid')
%matplotlib inline

g = sns.FacetGrid(train_df, col='Survived')
g.map(plt.hist, 'Age', bins=10)

Посмотрим на график выживаемости пассажиров в зависимости от класса и возраста

# Survived passengers by Pclass and Age
grid = sns.FacetGrid(train_df, col ='Survived', row ='Pclass', height = 3.5, aspect=1.5)
grid.map(plt.hist, 'Age', alpha=.5, bins=10)
grid.add_legend();

‘Cabin’

В колонке каюта ( ‘Cabin’) не указано 687 значений. Т. к. пропущенных значений много, можно удалить полностью колонку ‘Cabin’, а можно и оставить отсутствующие данные как — отсутствующие данные. Здесь важно понять: — Существует ли какая-то систематическая взаимосвязь между выживанием и тем, была ли у пассажира отдельная каюта.Для группировки используем метод groupby().

True — отсутствует упоминание о каюте

False — значение заполнено

#  missing cabin or not
# Relationship between the presence of a value in the "Cabin" column on the survival rate
train_df.groupby(train_df['Cabin'].isnull()).mean()

Те, пассажиры у кого запись отсутствует — выжили около 30%. А у кого запись о наличии каюты есть — выжило 67%.

Вывод: Есть взаимосвязь между выживанием и наличием каюты.

Решение:

Создать новую колонку ‘Cabin_available’ (бинарный классификатор).Используем метод where(), где прописываем условие: — Если значение в колонке ‘Cabin’ отсутствует, то присваиваем в колонке ‘Cabin_available’ — значение 0, если присутствует, то 1.

# Let's create a new column 'Cabin_available'
# If there is no value in the "Cabin" column, then = 0 and yes value = 1
train_df['Cabin_available'] = np.where(train_df['Cabin'].isnull(), 0,1)
train_df.head(6)

Выживаемость пассажиров в зависимости от наличия записи о каюте:

train_df.groupby(['Cabin_available']) ['Survived'].value_counts(normalize=True)

train_df.pivot_table(
  'PassengerId', 'Cabin_available', 'Survived', 'count').plot(
  kind='bar', stacked=True)

Теперь колонку ‘Cabin’ можно удалить.

train_df.drop(['Cabin'], axis = 1, inplace = True)
train_df

‘Embarked’

В колонке порт посадки на борт (‘Embarked’) не указано два значения. Это категориальный признак.

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

train_df['Embarked'].value_counts()

Чаще всего встречается значение S — 644. Нужно заменить пропущенные значения на S.

# replace the missing 'Embarked' values by the most frequent - S
train_df['Embarked'].replace(np.nan, 'S', inplace = True)
train_df['Embarked'].describe()

Good! Now, we have a dataset with no missing values. (Хорошо! Теперь у нас есть набор данных без пропущенных значений.)

train_df.isnull().sum()

Очень часто большие объемы данных, которые подготавливаются для последующего анализа, имеют пропуски. Для того, чтобы можно было использовать алгоритмы машинного обучения, строящие модели по этим данным, в большинстве случаев, необходимо эти пропуски чем-то и как-то заполнить. На вопрос “чем заполнять?” мы не будем отвечать в рамках данного урока, а вот на вопрос “как заполнять?” ответим.

1. pandas и отсутствующие данные
2. Замена отсутствующих данных
3. Удаление объектов/столбцов с отсутствующими данными

Для начала, хочется сказать, что в документации по библиотеке pandas есть целый раздел, посвященный данной тематике. 

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

In [1]: import pandas as pd
In [2]: from io import StringIO

После этого создадим объект в формате csv. CSV – это один из наиболее простых и распространенных форматов хранения данных, в котором элементы отделяются друг от друга запятыми, более подробно о нем можете прочитать здесь.

In [3]: data = 'price,count,percentn1,10,n2,20,51n3,30,'
In [4]: df = pd.read_csv(StringIO(data))

Полученный объект df – это DataFrame с пропусками.

In [5]: df
Out[5]:
  price count percent
0     1    10     NaN
1     2    20    51.0
2     3    30     NaN

В нашем примере, у объектов с индексами 0 и 2 отсутствуют данные в поле percent. Отсутствующие данные помечаются как NaN. Добавим к существующей структуре еще один объект (запись), у которого будет отсутствовать значение в поле count.

In [6]: df.loc[3] = {'price':4, 'count':None, 'percent':26.3}

In [7]: df
Out[7]:
  price count percent
0   1.0  10.0     NaN
1   2.0  20.0    51.0
2   3.0  30.0     NaN
3   4.0   NaN    26.3

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

In [8]: pd.isnull(df)
Out[8]:
  price count percent
0 False False    True
1 False False   False
2 False False    True
3 False True    False

Таким образом мы получаем таблицу того же размера, но на месте реальных данных в ней находятся логические переменные, которые принимают значение False, если значение поля у объекта есть, или True, если значение в данном поле – это NaN. В дополнение к этому можно посмотреть подробную информацию об объекте, для этого можно воспользоваться методом info().

In [9]: df.info()
<class 'pandas.core.frame.DataFrame'>
Int64Index: 4 entries, 0 to 3
Data columns (total 3 columns):
price 4 non-null float64
count 3 non-null float64
percent 2 non-null float64
dtypes: float64(3)
memory usage: 128.0 bytes

В нашем примере видно, что объект df имеет три столбца (count, percent и price), при этом в столбце price все объекты значимы – не NaN, в столбце count – один NaN объект, в поле percent – два NaN объекта. Можно воспользоваться следующим подходом для получения количества NaN элементов в записях.

In [10]: df.isnull().sum()
Out[10]:
price 0
count 1
percent 2
dtype: int64

Замена отсутствующих данных

Отсутствующие данные объектов можно заменить на конкретные числовые значения, для этого можно использовать метод fillna(). Для экспериментов будем использовать структуру df, созданную в предыдущем разделе.

In [11]: df.isnull().sum()
Out[11]:
price 0
count 1
percent 2
dtype: int64

In [12]: df
Out[12]:
  price count percent
0   1.0  10.0     NaN
1   2.0  20.0    51.0
2   3.0  30.0     NaN
3   4.0   NaN    26.3

In [13]: df.fillna(0)
Out[13]:
  price count percent
0   1.0  10.0     0.0
1   2.0  20.0    51.0
2   3.0  30.0     0.0
3   4.0   0.0    26.3

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

In [14]: df.fillna(df.mean())
Out[14]:
  price count percent
0   1.0  10.0   38.65
1   2.0  20.0   51.00
2   3.0  30.0   38.65
3   4.0  20.0   26.30

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

Удаление объектов/столбцов с отсутствующими данными

Довольно часто используемый подход при работе с отсутствующими данными – это удаление записей (строк) или полей (столбцов), в которых встречаются пропуски. Для того, чтобы удалить все объекты, которые содержат значения NaN воспользуйтесь методом dropna() без аргументов.

In [15]: df.dropna()
Out[15]:
  price count percent
1   2.0  20.0   51.0

Вместо записей, можно удалить поля, для этого нужно вызвать метод dropna с аргументом axis=1.

In [16]: df.dropna()
Out[16]:
  price count percent
1   2.0  20.0    51.0
In [17]: df.dropna(axis=1)
Out[17]:
  price
0   1.0
1   2.0
2   3.0
3   4.0

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

In [18]: df.dropna(axis = 1, thresh=3)
Out[18]:
  price count
0   1.0  10.0
1   2.0  20.0
2   3.0  30.0
3   4.0   NaN

P.S.

Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.

<<< Урок 3. Доступ к данным в структурах pandas

Missing Data can occur when no information is provided for one or more items or for a whole unit. Missing Data is a very big problem in a real-life scenarios. Missing Data can also refer to as NA(Not Available) values in pandas. In DataFrame sometimes many datasets simply arrive with missing data, either because it exists and was not collected or it never existed. For Example, Suppose different users being surveyed may choose not to share their income, some users may choose not to share the address in this way many datasets went missing.

In Pandas missing data is represented by two value:

• None: None is a Python singleton object that is often used for missing data in Python code.
• NaN : NaN (an acronym for Not a Number), is a special floating-point value recognized by all systems that use the standard IEEE floating-point representation

Pandas treat None and NaN as essentially interchangeable for indicating missing or null values. To facilitate this convention, there are several useful functions for detecting, removing, and replacing null values in Pandas DataFrame :

• isnull()
• notnull()
• dropna()
• fillna()
• replace()
• interpolate()

In this article we are using CSV file, to download the CSV file used, Click Here.

Checking for missing values using isnull() and notnull()

In order to check missing values in Pandas DataFrame, we use a function isnull() and notnull(). Both function help in checking whether a value is NaN or not. These function can also be used in Pandas Series in order to find null values in a series.

Checking for missing values using isnull()

In order to check null values in Pandas DataFrame, we use isnull() function this function return dataframe of Boolean values which are True for NaN values.

Code #1: 

Output:   

Code #2: 

Output: As shown in the output image, only the rows having Gender = NULL are displayed.

Checking for missing values using notnull()

In order to check null values in Pandas Dataframe, we use notnull() function this function return dataframe of Boolean values which are False for NaN values.

Code #3: 

Output:

Code #4:

Output: As shown in the output image, only the rows having Gender = NOT NULL are displayed.

Filling missing values using fillna(), replace() and interpolate()

In order to fill null values in a datasets, we use fillna(), replace() and interpolate() function these function replace NaN values with some value of their own. All these function help in filling a null values in datasets of a DataFrame. Interpolate() function is basically used to fill NA values in the dataframe but it uses various interpolation technique to fill the missing values rather than hard-coding the value.

Code #1: Filling null values with a single value 

Output:

Code #2: Filling null values with the previous ones 

Output:

Code #3: Filling null value with the next ones 

Output:

Code #4: Filling null values in CSV File 

Output

Now we are going to fill all the null values in Gender column with “No Gender”

Output:

Code #5: Filling a null values using replace() method 

Output:

Now we are going to replace the all Nan value in the data frame with -99 value. 

Output:

  Code #6: Using interpolate() function to fill the missing values using linear method. 

Output:

Let’s interpolate the missing values using Linear method. Note that Linear method ignore the index and treat the values as equally spaced. 

Output:

As we can see the output, values in the first row could not get filled as the direction of filling of values is forward and there is no previous value which could have been used in interpolation.  

Dropping missing values using dropna()

In order to drop a null values from a dataframe, we used dropna() function this function drop Rows/Columns of datasets with Null values in different ways.

Code #1: Dropping rows with at least 1 null value. 

Output

Now we drop rows with at least one Nan value (Null value) 

Output:

Code #2: Dropping rows if all values in that row are missing. 

Output

Now we drop a rows whose all data is missing or contain null values(NaN) 

Output:

Code #3: Dropping columns with at least 1 null value. 

Output

Now we drop a columns which have at least 1 missing values 

Output :

  Code #4: Dropping Rows with at least 1 null value in CSV file 

Output:

Now we compare sizes of data frames so that we can come to know how many rows had at least 1 Null value 

Output : 

Old data frame length: 1000
New data frame length: 764
Number of rows with at least 1 NA value:  236

Since the difference is 236, there were 236 rows which had at least 1 Null value in any column.

Last Updated :
09 Feb, 2023

Like Article

Save Article

np.where(pd.isnull(df)) returns the row and column indices where the value is NaN:

In [152]: import numpy as np
In [153]: import pandas as pd
In [154]: np.where(pd.isnull(df))
Out[154]: (array([2, 5, 6, 6, 7, 7]), array([7, 7, 6, 7, 6, 7]))

In [155]: df.iloc[2,7]
Out[155]: nan

In [160]: [df.iloc[i,j] for i,j in zip(*np.where(pd.isnull(df)))]
Out[160]: [nan, nan, nan, nan, nan, nan]

Finding values which are empty strings could be done with applymap:

In [182]: np.where(df.applymap(lambda x: x == ''))
Out[182]: (array([5]), array([7]))

Note that using applymap requires calling a Python function once for each cell of the DataFrame. That could be slow for a large DataFrame, so it would be better if you could arrange for all the blank cells to contain NaN instead so you could use pd.isnull.

Есть несколько стратегий индикации пропусков в данных

Использование некоего значения-индикатора

К примеру, можно использовать число -9999 или редко встречающееся сочетание битов. Более часто встречающийся способ — условное обозначение через NaN. NaN — это специальное значение, определенное спецификацией IEEE для чисел с плавающей точкой и используется во многих ЯП.

У метода есть ограничения. Во-первых использование значений индикаторов может привести к дополнительным не оптимизированным расчетам. Во-вторых NaN доступен не для всех типов данных.

Использование масок

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

Как это реализовано в Pandas?

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

В итоге в Pandas используется:

• индикаторы-числа

• NaN из Numpy

• None из Python

Объект None

None — объект python. Его нельзя использовать в NumPy и во всех производных массивах Pandas. None используется только в массивах с типом object. Когда мы создаем массив, используя None, автоматически создается массив с типом object.

Тип object означает, что NumPy не смог установить тип объектов массива, единственное что он знает — это то, что это объекты python. Операции с такими массивами будут производится на уровне языка python, т.е. со всеми накладными расходами, присущими языку с динамической типизацией. Оптимизация NumPy работать не будет.

Кроме того, функции агрегирования по массиву, например, massive.sum() или massive.min() выбросят ошибку, так как операции между численным значением и значением None не определены

Объект NaN

Объект NaN определяет отсутствие числового значения с плавающей точкой. Это вызывает некоторые проблемы — если NaN попадает в массив, все данные приводятся к числам с плавающей точкой. Кроме того, все операции с NaN приводят к NaN, в том числе и функции агрегирования.

Не забудьте, что для вызова объекта NaN нужен NumPy

Nan и None

Pandas преобразует None в NaN, если оба будут встречены в одном массиве. Естественно, осуществляется и повышающее преобразование с приведением всех непустых числовых значений к числу с плавающей точкой, а всех остальных к NaN.

pd.Series([1, np.nan, 3, None])
>>> 0    1.0
... 1    NaN
... 2    3.0
... 3    NaN
... dtype: float64

x = pd.Series([1, 2, 3], dtype='int8')
x
>>> 0    1
... 1    2
... 2    3
... dtype: int8

x[0] = None
x
>>> 0    NaN
... 1    2.0
... 2    3.0
... dtype: float64

Правила повышающих преобразований типов в Pandas (строки всегда хранятся как object)

Операции над пустыми значениями

В Pandas доступно несколько методов:

• isnull() — генерирует булеву маску для отсутствующих значений

• notnull() — тоже для непустых

• dropna() — фильтрация данных по отсутствующим значениям

• fillna() — замена пропусков с возвратом копии

Методы доступны как для объектов Series так и для dataFrame (с выбором измерения).

Кроме того, для dropna() ожно задать дополнительные параметры. how=’any’ задан по дефолту, можно переопределить как ‘all’ — будут отбрасываться только полностью пустые строки/столбцы. thresh задает минимальное значение непустых значений, выше которого строки/столбцы не отбрасываются.

Для fillna() доступно несколько аргументов. method=’ffill’ и method=’bfill’ определяют какими значениями будут заполняться пропуски (предыдущими или последующими в массиве).

Подробнее fillna() и dropna()