Python
Разъяснение NaN в Pandas: Руководство для начинающих

Разъяснение NaN в Pandas: Руководство для начинающих

MoeNagy Dev

Понимание основ pandas.isnull() и pandas.isna()

Изучение концепции pandas is nan

Что такое pandas.isnull() и pandas.isna()?

Функции pandas.isnull() и pandas.isna() используются для определения пропущенных значений в DataFrame или Series Pandas. Эти функции возвращают булевую маску того же размера, что и входные данные, где True указывает на пропущенное значение, а False - на непропущенное.

Вот пример:

import pandas as pd
 
# Создание примерного DataFrame
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})
 
# Проверка на пропущенные значения
print(df.isnull())
#       A     B
# 0  False False
# 1  False  True
# 2   True False
# 3  False False

В приведенном выше примере метод df.isnull() возвращает булевый DataFrame, указывающий на наличие пропущенных значений в каждой ячейке.

Понимание разницы между pandas.isnull() и pandas.isna()

Функции pandas.isnull() и pandas.isna() по сути одинаковы и могут использоваться взаимозаменяемо. Обе функции служат одной цели - определению пропущенных значений в DataFrame или Series.

Основное различие заключается в том, что pandas.isna() является более современным и рекомендуемым способом проверки на пропущенные значения, так как он обеспечивает лучшую поддержку различных типов данных, включая значения NaN в NumPy, None в Python и собственные индикаторы пропущенных значений Pandas.

В большинстве случаев вы можете использовать pandas.isna() вместо pandas.isnull() без каких-либо проблем. Однако, если вам необходимо сохранить совместимость со старыми версиями Pandas, вам может потребоваться использовать pandas.isnull().

Работа с пропущенными данными с помощью pandas is nan

Как только вы определили.Вот перевод на русский язык:

Для определения пропущенных значений можно использовать pandas.isnull() или pandas.isna(), а затем применить различные методы для их обработки. Некоторые распространенные техники включают:

  1. Замена пропущенных значений: Вы можете заменить пропущенные значения на конкретное значение или значение, рассчитанное на основе данных.
df['A'] = df['A'].fillna(0)  # Заменить пропущенные значения в столбце 'A' на 0
  1. Удаление строк или столбцов с пропущенными значениями:
df = df.dropna(subset=['A', 'B'])  # Удалить строки с любыми пропущенными значениями в столбцах 'A' или 'B'
  1. Заполнение пропущенных значений: Вы можете использовать различные методы заполнения, такие как заполнение средним, медианой или модой.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Интерполяция пропущенных значений: Для временных рядов вы можете использовать интерполяцию для оценки пропущенных значений на основе окружающих данных.
df = df.interpolate()  # Интерполировать пропущенные значения в DataFrame

Применение pandas.isnull() и pandas.isna() в манипуляциях с данными

Определение пропущенных значений в DataFrame

Вы можете использовать функции pandas.isnull() или pandas.isna() для определения пропущенных значений в DataFrame:

import pandas as pd
 
# Создание примерного DataFrame
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})
 
# Проверка на наличие пропущенных значений
print(df.isnull())
#       A     B
# 0  False False
# 1  False  True
# 2   True False
# 3  False False

Полученный булевый DataFrame указывает на наличие пропущенных значений в каждой ячейке.

Обработка пропущенных значений с использованием pandas.isnull() и pandas.isna()

Вы можете использовать булевую маску, возвращаемую pandas.isnull() или pandas.isna(), для выполнения различных операций с DataFrame, таких как:

  1. Замена пропущенных значений:
df['A'] = df['A'].fillna(0)
df['B'] = df['B'].fillna(df['B'].mean())
  1. Удаление строк или столбцов с пропущенными значениями:

```python
df = df.dropna(subset=['A', 'B'])  # Удалить строки с любыми пропущенными значениями в столбцах 'A' или 'B'
df = df.dropna(how='all')  # Удалить строки со всеми пропущенными значениями
df = df.dropna(axis=1)  # Удалить столбцы с любыми пропущенными значениями
  1. Заполнение пропущенных значений:
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])

Замена пропущенных значений на конкретное значение

Вы можете заменить пропущенные значения на конкретное значение, используя метод fillna():

# Заменить пропущенные значения в столбце 'A' на 0
df['A'] = df['A'].fillna(0)
 
# Заменить пропущенные значения в столбце 'B' на среднее значение столбца
df['B'] = df['B'].fillna(df['B'].mean())

Удаление строк или столбцов с пропущенными значениями

Вы можете удалить строки или столбцы с пропущенными значениями, используя метод dropna():

# Удалить строки с любыми пропущенными значениями в столбцах 'A' или 'B'
df = df.dropna(subset=['A', 'B'])
 
# Удалить строки со всеми пропущенными значениями
df = df.dropna(how='all')
 
# Удалить столбцы с любыми пропущенными значениями
df = df.dropna(axis=1)

Расширенные техники с pandas is nan

Комбинирование pandas.isnull() и pandas.isna() с другими методами DataFrame

Вы можете комбинировать функции pandas.isnull() или pandas.isna() с другими методами DataFrame для выполнения более сложных операций. Например, вы можете использовать их в условной фильтрации, преобразовании данных и многом другом.

# Фильтровать строки с пропущенными значениями в столбце 'A'
filtered_df = df[df['A'].isnull()]
 
# Заполнить пропущенные значения в столбце 'B' медианой непропущенных значений в этом столбце
df['B'] = df['B'].fillna(df['B'].median())
 
# Создать новый столбец, указывающий на наличие пропущенных значений в столбце 'A'
df['has_missing_A'] = df['A'].isnull()

Условная фильтрация на основе пропущенных значений

Вы можете использовать булевую маску, возвращаемую pandas.isnull() или pandas.isna(), для выполнения условной фильтрации в вашем DataFrame:

# Фильтрация.
```Вот перевод на русский язык:
 
строки с пропущенными значениями в столбце 'A'
filtered_df = df[df['A'].isnull()]
 
# Фильтрация строк с ненулевыми значениями в столбце 'B'
non_missing_df = df[~df['B'].isnull()]

Заполнение пропущенных значений с помощью различных методов

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

  1. Заполнение средним/медианой/модой:
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Заполнение с помощью KNN:
from fancyimpute import KNNImputer
imputer = KNNImputer(n_neighbors=5)
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Итеративное заполнение:
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
imputer = IterativeImputer()
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])

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

Изучение конкретных вариантов использования pandas.isna()

Очистка и предварительная обработка данных с помощью pandas.isna()

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

Вот пример того, как вы можете использовать pandas.isna() для очистки и предварительной обработки набора данных:

import pandas as pd
 
# Загрузка набора данных
df = pd.read_csv('dataset.csv')
 
# Определение пропущенных значений
missing_values = df.isna().sum()
print(missing_values)
 
# Удаление строк с пропущенными значениями в любом столбце
df = df.dropna()
 
# Заполнение пропущенных значений в столбце 'age' медианой
df['age'] = df['age'].fillna(df['age'].median())
 
# Создание нового столбца, указывающего на наличие пропущенных значений в столбце 'income'
df['has_m.Вот перевод на русский язык:
 
```python
df['missing_income'] = df['income'].isna()

В этом примере мы сначала определяем количество пропущенных значений в каждом столбце, используя df.isna().sum(). Затем мы удаляем любые строки с пропущенными значениями в любом столбце и заполняем пропущенные значения в столбце 'age' медианой. Наконец, мы создаем новый столбец, который указывает на наличие пропущенных значений в столбце 'income'.

Обработка пропущенных значений в данных временных рядов

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

import pandas as pd
 
# Создание примера DataFrame временных рядов
df = pd.DataFrame({'A': [1, 2, None, 4, 5], 'B': [5, None, 7, 8, 9]},
                  index=pd.date_range('2022-01-01', periods=5, freq='D'))
 
# Определение пропущенных значений
print(df.isna())
#             A     B
# 2022-01-01 False False
# 2022-01-02 False  True
# 2022-01-03  True False
# 2022-01-04 False False
# 2022-01-05 False False
 
# Интерполяция пропущенных значений
df = df.interpolate()
print(df)
#             A    B
# 2022-01-01  1  5.0
# 2022-01-02  2  6.0
# 2022-01-03  3  7.0
# 2022-01-04  4  8.0
# 2022-01-05  5  9.0

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

Работа с пропущенными значениями в моделях машинного обучения

Пропущенные значения могут оказывать значительное влияние на производительность моделей машинного обучения. pandas.isnull() и pandas.isna() можно использовать для определения и обработки пропущенных значений перед передачей данных в модель машинного обучения.

import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LinearRegression
 
# Загрузка набора данных
df = pd.read_csv('dataset.csv')
 
# Определение пропущенных значений
missing_values = df.isna().sum()
print(missing_values)
 
# Им.
```Заполнение пропущенных значений с использованием средней импутации
imputer = SimpleImputer(strategy='mean')
X = imputer.fit_transform(df.drop('target', axis=1))
y = df['target']
 
# Обучение линейной регрессионной модели
model = LinearRegression()
model.fit(X, y)

В этом примере мы сначала определяем пропущенные значения в наборе данных с помощью df.isna().sum(). Затем мы используем SimpleImputer из scikit-learn для заполнения пропущенных значений средним значением каждой функции. Наконец, мы обучаем линейную регрессионную модель на заполненных данных.

Обработка пропущенных значений является критическим шагом в подготовке данных для моделей машинного обучения, так как многие модели не могут напрямую работать с пропущенными значениями. Используя pandas.isnull() и pandas.isna(), вы можете убедиться, что

Функции

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

Вот пример простой функции, которая вычисляет площадь прямоугольника:

def calculate_area(length, width):
    """
    Вычисляет площадь прямоугольника.
 
    Аргументы:
        length (float): Длина прямоугольника.
        width (float): Ширина прямоугольника.
 
    Возвращает:
        float: Площадь прямоугольника.
    """
    area = length * width
    return area
 
# Использование
rectangle_length = 5.0
rectangle_width = 3.0
rectangle_area = calculate_area(rectangle_length, rectangle_width)
print(f"Площадь прямоугольника составляет {rectangle_area} квадратных единиц.")

В этом примере функция calculate_area принимает два параметра, length и width, и возвращает вычисленную площадь. Функция также включает в себя строку документации, которая предоставляет краткое описание функции, а также ожидаемые параметры и возвращаемое значение.

Модули и пакеты

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

Модули и пакеты для организации вашего кода и повышения его повторного использования.

Вот пример того, как создать простой модуль:

# my_module.py
def greet(name):
    """
    Приветствует человека с указанным именем.
 
    Аргументы:
        name (str): Имя человека, которого нужно приветствовать.
 
    Возвращает:
        str: Сообщение приветствия.
    """
    return f"Привет, {name}!"

Чтобы использовать модуль, вы можете импортировать его в другой Python-файл:

# main.py
import my_module
 
greeting = my_module.greet("Алиса")
print(greeting)  # Вывод: Привет, Алиса!

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

my_package/
    __init__.py
    utils/
        __init__.py
        math_functions.py
        string_functions.py

Файлы __init__.py используются для определения структуры пакета и указания, какие модули должны быть импортированы при импорте пакета.

# my_package/utils/math_functions.py
def add(a, b):
    return a + b
 
def subtract(a, b):
    return a - b
# main.py
from my_package.utils import math_functions
 
result = math_functions.add(5, 3)
print(result)  # Вывод: 8

Исключения

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

Вот пример того, как обработать исключение ZeroDivisionError:

def divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Ошибка: Деление на ноль.")
        return None
 
print(divide(10, 2))  # Вывод: 5.0
print(divide(10, 0))  # Вывод: Ошибка: Деление на ноль.

В этом примере функция divide пытается разделить первый аргумент на второй аргумент. Если возникает ZeroDivisionError, функция выводит сообщение об ошибке и возвращает None.Вот перевод на русский язык:

Если возникает исключение DivisionError, функция перехватывает это исключение и выводит сообщение об ошибке, а затем возвращает None.

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

class NegativeValueError(Exception):
    """Возникает, когда встречается отрицательное значение."""
    pass
 
def calculate_square_root(number):
    if number < 0:
        raise NegativeValueError("Невозможно вычислить квадратный корень из отрицательного числа.")
    return number ** 0.5
 
try:
    print(calculate_square_root(16))  # Вывод: 4.0
    print(calculate_square_root(-4))
except NegativeValueError as e:
    print(e)  # Вывод: Невозможно вычислить квадратный корень из отрицательного числа.

В этом примере функция calculate_square_root генерирует пользовательское исключение NegativeValueError, если входное число отрицательное. Это исключение затем перехватывается и обрабатывается в блоке try-except.

Ввод/вывод файлов

Python предоставляет встроенные функции и методы для чтения и записи файлов. Наиболее распространенный способ работы с файлами - использование функции open(), которая возвращает объект файла, который можно использовать для выполнения различных операций с файлами.

Вот пример того, как читать и писать в файл:

# Запись в файл
with open("example.txt", "w") as file:
    file.write("Это первая строка.\n")
    file.write("Это вторая строка.\n")
 
# Чтение из файла
with open("example.txt", "r") as file:
    contents = file.read()
    print(contents)
    # Вывод:
    # Это первая строка.
    # Это вторая строка.

В этом примере функция open() используется для открытия файла с именем "example.txt" в режиме записи ("w") и записи двух строк текста. Затем файл открывается в режиме чтения ("r") и его содержимое читается и выводится.

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

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

with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())
    # Вывод:
    # Это первая строка.
    # Это вторая строка.

В этом примере метод strip() используется для удаления символа новой строки из каждой строки.

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

Регулярные выражения (regex) - это мощный инструмент для сопоставления шаблонов и манипулирования текстом. Встроенный модуль re Python предоставляет всеобъемлющий набор функций и методов для работы с регулярными выражениями.

Вот пример того, как использовать регулярные выражения для проверки действительности адреса электронной почты:

import re
 
def is_valid_email(email):
    """
    Проверяет, является ли данный адрес электронной почты действительным.
 
    Аргументы:
        email (str): Адрес электронной почты для проверки.
 
    Возвращает:
        bool: True, если адрес электронной почты действителен, False в противном случае.
    """
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    if re.match(pattern, email):
        return True
    else:
        return False
 
print(is_valid_email("example@example.com"))  # Вывод: True
print(is_valid_email("invalid_email"))  # Вывод: False

В этом примере функция is_valid_email принимает адрес электронной почты в качестве входных данных и использует регулярное выражение для проверки его действительности. Функция re.match() используется для применения шаблона к адресу электронной почты и возвращения булевого результата.

Регулярные выражения могут использоваться для широкого спектра задач обработки текста, таких как:

  • Поиск конкретных шаблонов в тексте
  • Извлечение информации из текста
  • Замена или модификация текста на основе шаблонов
  • Проверка входных данных

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

Заключение

В этом руководстве вы узнали о различных промежуточных уровнях P.Вот перевод на русский язык:

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

Помните, что лучший способ улучшить свои навыки Python - это практиковаться, экспериментировать и постоянно учиться. Исследуйте стандартную библиотеку Python, читайте документацию и участвуйте в онлайн-сообществах, чтобы расширять свои знания и быть в курсе последних событий в экосистеме Python.

Счастливого кодирования!

MoeNagy Dev.