Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

в этой функции мне необходимо добавить сравнение еще по полю 'status': 'Статус' def…

  1. User

    в этой функции мне необходимо добавить сравнение еще по полю 'status': 'Статус' def compare_dataframes(dfmain, dfchange, file_name): # Определяем соответствие полей для сравнения field_mapping = { 'rues_name': 'Подразделение', 'ceh_name': 'Участок', 'equipment_type_name': 'Тип', 'equipment_name': 'Название', 'mac': 'MAC адрес', 'serial_number': 'Серийный номер', 'status': 'Статус' }

    # Функция для поиска совпадений
    def find_matching_rows(index, row, search_field):
        # Основное поле для поиска (mac или serial_number)
        search_value = row[search_field]
        # Фильтруем dfmain по значению поля
        matches = dfmain[dfmain[search_field] == search_value]
        
        return matches
    
    # Объединяем DataFrame dfchange и dfmain
    merged_df = pd.merge(
        dfchange,
        dfmain,
        how='left',
        left_on=['Участок', 'MAC адрес', 'Серийный номер'],
        right_on=['ceh_name', 'mac', 'serial_number'],
        suffixes=('_change', '_main')
    )
    
    # Сохраняем объединённый DataFrame в Excel
    output_file = f"{file_name.rsplit('.', 1)[0]}.xlsx"
    merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
    # Проверка совпадений по полям
    for index, row in merged_df.iterrows():
        # Сначала ищем по 'mac'
        matches = find_matching_rows(index, row, 'mac')
    
        # Если совпадений нет, ищем по 'serial_number'
        if matches.shape[0] == 0:
            matches = find_matching_rows(index, row, 'serial_number')
    
        # Проверяем количество найденных совпадений
        if matches.shape[0] == 0:
            print(f"{index}: Не найдено соответствие для MAC: {row['mac']}, Серийный номер: {row['serial_number']}.")
            continue
        
        # Если найдено более одного совпадения, выводим сообщение
        if matches.shape[0] > 1:
            print(f"{index}: Найдено {matches.shape[0]} совпадений для MAC: {row['mac']}.")
    
        # Проверка значений для совпадающих строк
        for dfmain_field, dfchange_field in field_mapping.items():
            main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
            change_value = row.get(dfchange_field)
    
            # Сравнение значений и вывод результата
            if main_value != change_value:
                print(f"{index} Несоответствие для '{dfchange_field}' - "
                      f"MAC: {row['mac'] if pd.notnull(row['mac']) else 'N/A'}, "
                      f"Серийный номер: {row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A'}, "
                      f"Значения: {main_value} != {change_value}")
    
  2. Assistant

    Для добавления сравнения по полю 'status': 'Статус' в вашей функции compare_dataframes, необходимо убедиться, что это поле также включено в процесс объединения DataFrame, чтобы вы могли сравнивать его значения. Давайте внесем необходимые изменения.

    Вот обновленный код функции:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус'  # Добавлено поле 'status'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(index, row, search_field):
            search_value = row[search_field]
            matches = dfmain[dfmain[search_field] == search_value]
            return matches
    
        # Объединяем DataFrame dfchange и dfmain, включая поле 'status'
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер'],
            right_on=['ceh_name', 'mac', 'serial_number'],
            suffixes=('_change', '_main')
        )
    
        # Сохраняем объединённый DataFrame в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            # Сначала ищем по 'mac'
            matches = find_matching_rows(index, row, 'mac')
    
            # Если совпадений нет, ищем по 'serial_number'
            if matches.shape[0] == 0:
                matches = find_matching_rows(index, row, 'serial_number')
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                print(f"{index}: Не найдено соответствие для MAC: {row['mac']}, Серийный номер: {row['serial_number']}.")
                continue
            
            # Если найдено более одного совпадения, выводим сообщение
            if matches.shape[0] > 1:
                print(f"{index}: Найдено {matches.shape[0]} совпадений для MAC: {row['mac']}.")
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Сравнение значений и вывод результата
                if main_value != change_value:
                    print(f"{index} Несоответствие для '{dfchange_field}' - "
                          f"MAC: {row['mac'] if pd.notnull(row['mac']) else 'N/A'}, "
                          f"Серийный номер: {row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A'}, "
                          f"Значения: {main_value} != {change_value}")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    В этом коде добавлено сравнение для поля status, чтобы оно включалось в процесс проверки несовпадений. Убедитесь, что в dfchange и dfmain есть соответствующие поля для правильной работы.

  3. User

    давай перепишем функцию так, что бы она выбирала значения сразу по трём полям 'mac': 'MAC адрес', 'serial_number': 'Серийный номер', 'status': 'Статус' и отмечала несоответствия если такие записи не найдены или их больше одной

  4. Assistant

    Давайте перепишем вашу функцию так, чтобы она использовала сразу три поля для поиска совпадений: 'mac', 'serial_number' и 'status'. Если записи не будут найдены или их будет больше одной, функция будет отмечать эти несоответствия.

    Ниже приведена обновленная версия функции compare_dataframes:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row):
            conditions = (
                (dfmain['mac'] == row['mac']) &
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status'])
            )
            return dfmain[conditions]
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status'],
            suffixes=('_change', '_main')
        )
    
        # Сохраняем объединённый DataFrame в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            matches = find_matching_rows(row)
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                print(f"{index}: Не найдено соответствие для MAC: {row['mac']}, "
                      f"Серийный номер: {row['serial_number']}, Статус: {row['status']}.")
                continue
            
            if matches.shape[0] > 1:
                print(f"{index}: Найдено {matches.shape[0]} совпадений для MAC: {row['mac']}.")
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Сравнение значений и вывод результата
                if main_value != change_value:
                    print(f"{index} Несоответствие для '{dfchange_field}' - "
                          f"MAC: {row['mac'] if pd.notnull(row['mac']) else 'N/A'}, "
                          f"Серийный номер: {row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A'}, "
                          f"Статус: {row['status'] if pd.notnull(row['status']) else 'N/A'}, "
                          f"Значения: {main_value} != {change_value}")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Изменения в функции:

    1. Найдите совпадения по трем полям: Вместо того чтобы искать совпадения только по mac и serial_number, теперь используется также status в функции find_matching_rows.

    2. Отметить несоответствия: Если не найдено ни одной строки или найдено более одной строки, это отмечается в сообщении.

    3. Сравнение значений: Сравнение всех полей из field_mapping происходит так же, как и раньше.

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

  5. User

    сделай вывод результата в файл

  6. Assistant

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

    Вот обновленная версия функции с выводом результатов в файл:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row):
            conditions = (
                (dfmain['mac'] == row['mac']) &
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status'])
            )
            return dfmain[conditions]
    
        # Список для хранения результатов несоответствий
        discrepancies = []
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status'],
            suffixes=('_change', '_main')
        )
    
        # Сохраняем объединённый DataFrame в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}_merged.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            matches = find_matching_rows(row)
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Message': 'Не найдено соответствие'
                })
                continue
            
            if matches.shape[0] > 1:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Message': f'Найдено {matches.shape[0]} совпадений'
                })
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Сравнение значений и добавление в список несоответствий
                if main_value != change_value:
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'] if pd.notnull(row['mac']) else 'N/A',
                        'Serial Number': row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A',
                        'Status': row['status'] if pd.notnull(row['status']) else 'N/A',
                        'Column': dfchange_field,
                        'Value Main': main_value,
                        'Value Change': change_value,
                        'Message': 'Несоответствие'
                    })
    
        # Сохраняем результаты несоответствий в файл
        if discrepancies:
            discrepancies_df = pd.DataFrame(discrepancies)
            discrepancies_file = f"{file_name.rsplit('.', 1)[0]}_discrepancies.xlsx"
            discrepancies_df.to_excel(discrepancies_file, index=False)
            print(f"Результаты несоответствий сохранены в файл: {discrepancies_file}")
        else:
            print("Несоответствий не найдено.")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Изменения в функции:

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

    2. Сохранение результатов в файл: Если в списке discrepancies есть элементы, они преобразуются в DataFrame и сохраняются в Excel файл. Название файла формируется на основе исходного имени, добавляя суффикс _discrepancies.

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

    Таким образом, вы сможете легко отслеживать все несоответствия и результаты проверки.

  7. User

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

  8. Assistant

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

    Вот обновленная версия функции compare_dataframes, учитывающая NaN значения:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row):
            conditions = (
                (dfmain['mac'] == row['mac']) &
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status'])
            )
            return dfmain[conditions]
    
        # Список для хранения результатов несоответствий
        discrepancies = []
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status'],
            suffixes=('_change', '_main')
        )
    
        # Сохраняем объединённый DataFrame в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}_merged.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            # Проверка на наличие пустого поля
            if pd.isna(row['mac']) or pd.isna(row['serial_number']) or pd.isna(row['status']):
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Message': 'Одно или несколько полей пустые'
                })
                continue
    
            matches = find_matching_rows(row)
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Message': 'Не найдено соответствие'
                })
                continue
            
            if matches.shape[0] > 1:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Message': f'Найдено {matches.shape[0]} совпадений'
                })
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Сравнение значений и добавление в список несоответствий
                if main_value != change_value:
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'] if pd.notnull(row['mac']) else 'N/A',
                        'Serial Number': row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A',
                        'Status': row['status'] if pd.notnull(row['status']) else 'N/A',
                        'Column': dfchange_field,
                        'Value Main': main_value,
                        'Value Change': change_value,
                        'Message': 'Несоответствие'
                    })
    
        # Сохраняем результаты несоответствий в файл
        if discrepancies:
            discrepancies_df = pd.DataFrame(discrepancies)
            discrepancies_file = f"{file_name.rsplit('.', 1)[0]}_discrepancies.xlsx"
            discrepancies_df.to_excel(discrepancies_file, index=False)
            print(f"Результаты несоответствий сохранены в файл: {discrepancies_file}")
        else:
            print("Несоответствий не найдено.")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Изменения в функции:

    1. Проверка на NaN: Перед поиском совпадений, добавлена проверка на наличие NaN для полей mac, serial_number и status. Если хотя бы одно из этих полей пустое, функция записывает это несоответствие и переходит к следующей записи.

    2. Сообщение о пустых полях: Добавлено сообщение о том, что одно или несколько полей пустые, чтобы можно было легко увидеть, где проблема.

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

  9. User

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

  10. Assistant

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

    Вот как можно изменить вашу функцию, чтобы учитывать пустые значения и проверять, соответствуют ли они:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row):
            conditions = (
                (dfmain['mac'] == row['mac']) &
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status'])
            )
            return dfmain[conditions]
    
        # Список для хранения результатов несоответствий
        discrepancies = []
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status'],
            suffixes=('_change', '_main')
        )
    
        # Сохраняем объединённый DataFrame в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}_merged.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            matches = find_matching_rows(row)
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Message': 'Не найдено соответствие'
                })
                continue
            
            if matches.shape[0] > 1:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Message': f'Найдено {matches.shape[0]} совпадений'
                })
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Проверка на соответствие NaN
                if (pd.isna(main_value) and pd.isna(change_value)):
                    continue  # Они равны, если оба NaN
    
                # Сравнение значений и добавление в список несоответствий
                if main_value != change_value:
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'] if pd.notnull(row['mac']) else 'N/A',
                        'Serial Number': row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A',
                        'Status': row['status'] if pd.notnull(row['status']) else 'N/A',
                        'Column': dfchange_field,
                        'Value Main': main_value,
                        'Value Change': change_value,
                        'Message': 'Несоответствие'
                    })
    
        # Сохраняем результаты несоответствий в файл
        if discrepancies:
            discrepancies_df = pd.DataFrame(discrepancies)
            discrepancies_file = f"{file_name.rsplit('.', 1)[0]}_discrepancies.xlsx"
            discrepancies_df.to_excel(discrepancies_file, index=False)
            print(f"Результаты несоответствий сохранены в файл: {discrepancies_file}")
        else:
            print("Несоответствий не найдено.")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Изменения в функции:

    1. Сравнение NaN значений: Добавлена проверка, которая сравнивает значения main_value и change_value. Если оба значения равны NaN, проверка проходит успешно, и мы не добавляем это в несоответствия.

    2. Не пропускаем записи: Записи с пустыми значениями теперь будут проверяться на соответствие, и если значения NaN совпадают в обоих DataFrame, они не будут вызывать несоответствий.

    Теперь ваша функция будет учитывать пустые значения и правильно обрабатывать случаи с NaN в обоих DataFrame.

  11. User

    если mac пустой, то пишет "не найдено соответствие", хотя записи идентичны

  12. Assistant

    Чтобы исправить ситуацию, в которой функция сообщает о "не найдено соответствие", когда поле mac пустое (NaN), нам нужно учесть, что если оба значения mac пустые (или NaN), они следует считать идентичными.

    Для этого мы можем добавить специальную логику для проверки полей mac, serial_number и status перед поиском совпадений. Таким образом, если обе записи имеют пустое значение для mac, мы не будем добавлять это как несоответствие, а будем считать их эквивалентными.

    Ниже приведен обновленный код:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row):
            conditions = (
                (dfmain['mac'] == row['mac']) &
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status'])
            )
            return dfmain[conditions]
    
        # Список для хранения результатов несоответствий
        discrepancies = []
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status'],
            suffixes=('_change', '_main')
        )
    
        # Сохраняем объединённый DataFrame в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}_merged.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            matches = find_matching_rows(row)
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                # Проверка на пустые значения
                if pd.isna(row['mac']) and pd.isna(row['serial_number']) and pd.isna(row['status']):
                    continue  # Пропускаем, если все поля пустые
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Message': 'Не найдено соответствие'
                })
                continue
            
            if matches.shape[0] > 1:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Message': f'Найдено {matches.shape[0]} совпадений'
                })
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Проверка на соответствие NaN
                if (pd.isna(main_value) and pd.isna(change_value)):
                    continue  # Они равны, если оба NaN
    
                # Сравнение значений и добавление в список несоответствий
                if main_value != change_value:
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'] if pd.notnull(row['mac']) else 'N/A',
                        'Serial Number': row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A',
                        'Status': row['status'] if pd.notnull(row['status']) else 'N/A',
                        'Column': dfchange_field,
                        'Value Main': main_value,
                        'Value Change': change_value,
                        'Message': 'Несоответствие'
                    })
    
        # Сохраняем результаты несоответствий в файл
        if discrepancies:
            discrepancies_df = pd.DataFrame(discrepancies)
            discrepancies_file = f"{file_name.rsplit('.', 1)[0]}_discrepancies.xlsx"
            discrepancies_df.to_excel(discrepancies_file, index=False)
            print(f"Результаты несоответствий сохранены в файл: {discrepancies_file}")
        else:
            print("Несоответствий не найдено.")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Что изменено:

    1. Проверка пустых полей: Теперь перед тем, как добавить запись о несовпадении, мы проверяем, являются ли все три поля (mac, serial_number, и status) пустыми. Если это так, то мы просто пропускаем эту запись и продолжаем итерацию.

    2. Оптимизация обработки пустых MAC: Теперь если mac пустой и все остальные поля также пустые, запись не будет считаться несоответствием.

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

  13. User

    добавь сравнение по 'last_updated': 'Дата изменения статуса'

  14. Assistant

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

    Вот обновленная версия функции compare_dataframes, которая включает новое поле:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус',
            'last_updated': 'Дата изменения статуса'  # Добавлено новое поле
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row):
            conditions = (
                (dfmain['mac'] == row['mac']) &
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status']) &
                (dfmain['last_updated'] == row['last_updated'])  # Условия для last_updated
            )
            return dfmain[conditions]
    
        # Список для хранения результатов несоответствий
        discrepancies = []
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус', 'Дата изменения статуса'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status', 'last_updated'],
            suffixes=('_change', '_main')
        )
    
        # Сохраняем объединённый DataFrame в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}_merged.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            matches = find_matching_rows(row)
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                # Проверка на пустые значения
                if pd.isna(row['mac']) and pd.isna(row['serial_number']) and pd.isna(row['status']) and pd.isna(row['last_updated']):
                    continue  # Пропускаем, если все поля пустые
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Last Updated': row['last_updated'],
                    'Message': 'Не найдено соответствие'
                })
                continue
            
            if matches.shape[0] > 1:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Last Updated': row['last_updated'],
                    'Message': f'Найдено {matches.shape[0]} совпадений'
                })
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Проверка на соответствие NaN
                if (pd.isna(main_value) and pd.isna(change_value)):
                    continue  # Они равны, если оба NaN
    
                # Сравнение значений и добавление в список несоответствий
                if main_value != change_value:
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'] if pd.notnull(row['mac']) else 'N/A',
                        'Serial Number': row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A',
                        'Status': row['status'] if pd.notnull(row['status']) else 'N/A',
                        'Last Updated': row['last_updated'] if pd.notnull(row['last_updated']) else 'N/A',
                        'Column': dfchange_field,
                        'Value Main': main_value,
                        'Value Change': change_value,
                        'Message': 'Несоответствие'
                    })
    
        # Сохраняем результаты несоответствий в файл
        if discrepancies:
            discrepancies_df = pd.DataFrame(discrepancies)
            discrepancies_file = f"{file_name.rsplit('.', 1)[0]}_discrepancies.xlsx"
            discrepancies_df.to_excel(discrepancies_file, index=False)
            print(f"Результаты несоответствий сохранены в файл: {discrepancies_file}")
        else:
            print("Несоответствий не найдено.")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Изменения:

    1. Добавление нового поля: Поле last_updated теперь добавлено в field_mapping, а также в условия объединения pd.merge и в проверку совпадений.

    2. Обновление блоков кода, которые обрабатывают несоответствия: Добавлено поле "Дата изменения статуса" в все сообщения о несоответствиях, чтобы вы могли видеть, какая именно запись вызвала несоответствие.

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

  15. User

    если mac nan то используй вместо него 'equipment_name': 'Название' для сравнения

  16. Assistant

    Для того чтобы использовать поле 'equipment_name' в случае, если значение mac пустое (NaN), нужно изменить логику поиска совпадений. Если mac равно NaN, мы будем использовать значение из equipment_name для поиска совпадений.

    Вот обновленная версия функции с этой логикой:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус',
            'last_updated': 'Дата изменения статуса'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row):
            # Используем equipment_name вместо mac, если mac пустой
            mac_value = row['mac'] if pd.notna(row['mac']) else row['equipment_name']
            
            conditions = (
                (dfmain['mac'] == mac_value) &
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status']) &
                (dfmain['last_updated'] == row['last_updated'])
            )
            return dfmain[conditions]
    
        # Список для хранения результатов несоответствий
        discrepancies = []
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус', 'Дата изменения статуса'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status', 'last_updated'],
            suffixes=('_change', '_main')
        )
    
        # Сохраняем объединённый DataFrame в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}_merged.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            matches = find_matching_rows(row)
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                # Проверка на пустые значения
                if pd.isna(row['mac']) and pd.isna(row['serial_number']) and pd.isna(row['status']) and pd.isna(row['last_updated']):
                    continue  # Пропускаем, если все поля пустые
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Last Updated': row['last_updated'],
                    'Message': 'Не найдено соответствие'
                })
                continue
            
            if matches.shape[0] > 1:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Last Updated': row['last_updated'],
                    'Message': f'Найдено {matches.shape[0]} совпадений'
                })
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Проверка на соответствие NaN
                if (pd.isna(main_value) and pd.isna(change_value)):
                    continue  # Они равны, если оба NaN
    
                # Сравнение значений и добавление в список несоответствий
                if main_value != change_value:
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'] if pd.notnull(row['mac']) else 'N/A',
                        'Serial Number': row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A',
                        'Status': row['status'] if pd.notnull(row['status']) else 'N/A',
                        'Last Updated': row['last_updated'] if pd.notnull(row['last_updated']) else 'N/A',
                        'Column': dfchange_field,
                        'Value Main': main_value,
                        'Value Change': change_value,
                        'Message': 'Несоответствие'
                    })
    
        # Сохраняем результаты несоответствий в файл
        if discrepancies:
            discrepancies_df = pd.DataFrame(discrepancies)
            discrepancies_file = f"{file_name.rsplit('.', 1)[0]}_discrepancies.xlsx"
            discrepancies_df.to_excel(discrepancies_file, index=False)
            print(f"Результаты несоответствий сохранены в файл: {discrepancies_file}")
        else:
            print("Несоответствий не найдено.")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Изменения:

    1. Логика поиска совпадений: Теперь, если значение mac равно NaN, будет использоваться значение equipment_name для поиска совпадений, что позволяет учитывать записи, которые могут идентифицироваться по другим полям.

    2. Поддержка проверки значений: Логика сравнения значений остается прежней, с проверкой на NaN и добавлением результатов несоответствий в список.

    Теперь функция будет правильно проверять записи, когда значение mac отсутствует, используя вместо этого поле equipment_name.

  17. User

    у меня по прежнему нормально не сравниваются записи с пустым mac. сделай вывод отладочной информации с полными записями при получении "Не найдено соответствие"

  18. Assistant

    Чтобы улучшить отладку функционала и понять, почему записи с пустым MAC не сравниваются корректно, можно добавить вывод отладочной информации при каждой ситуации, когда возникает сообщение "Не найдено соответствие". Мы можем выводить полные записи из dfmain и dfchange, чтобы увидеть, что именно происходит.

    Вот обновленный код функции, который включает отладочную информацию:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус',
            'last_updated': 'Дата изменения статуса'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row):
            # Используем equipment_name вместо mac, если mac пустой
            mac_value = row['mac'] if pd.notna(row['mac']) else row['equipment_name']
            
            conditions = (
                (dfmain['mac'] == mac_value) &
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status']) &
                (dfmain['last_updated'] == row['last_updated'])
            )
            return dfmain[conditions]
    
        # Список для хранения результатов несоответствий
        discrepancies = []
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус', 'Дата изменения статуса'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status', 'last_updated'],
            suffixes=('_change', '_main')
        )
    
        # Экспортируем объединённые данные в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}_merged.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            matches = find_matching_rows(row)
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                # Проверка на пустые значения
                if pd.isna(row['mac']) and pd.isna(row['serial_number']) and pd.isna(row['status']) and pd.isna(row['last_updated']):
                    continue  # Пропускаем, если все поля пустые
                
                # Вывод отладочной информации
                print(f"Не найдено соответствие для записи на индексе {index}:")
                print("Запись в dfchange:")
                print(row.to_dict())
                print("Записи в dfmain:")
                print(dfmain[dfmain['mac'] if pd.notna(row['mac']) else 'equipment_name'] == row['mac'])
                print("\n")
    
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Last Updated': row['last_updated'],
                    'Message': 'Не найдено соответствие'
                })
                continue
            
            if matches.shape[0] > 1:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Last Updated': row['last_updated'],
                    'Message': f'Найдено {matches.shape[0]} совпадений'
                })
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Проверка на соответствие NaN
                if (pd.isna(main_value) and pd.isna(change_value)):
                    continue  # Они равны, если оба NaN
    
                # Сравнение значений и добавление в список несоответствий
                if main_value != change_value:
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'] if pd.notnull(row['mac']) else 'N/A',
                        'Serial Number': row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A',
                        'Status': row['status'] if pd.notnull(row['status']) else 'N/A',
                        'Last Updated': row['last_updated'] if pd.notnull(row['last_updated']) else 'N/A',
                        'Column': dfchange_field,
                        'Value Main': main_value,
                        'Value Change': change_value,
                        'Message': 'Несоответствие'
                    })
    
        # Сохраняем результаты несоответствий в файл
        if discrepancies:
            discrepancies_df = pd.DataFrame(discrepancies)
            discrepancies_file = f"{file_name.rsplit('.', 1)[0]}_discrepancies.xlsx"
            discrepancies_df.to_excel(discrepancies_file, index=False)
            print(f"Результаты несоответствий сохранены в файл: {discrepancies_file}")
        else:
            print("Несоответствий не найдено.")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Изменения:

    1. Вывод отладочной информации: При каждом случае, когда не находится соответствие, теперь выводится информация о записи из dfchange (используется row.to_dict() для формирования читаемого словаря) и записи из dfmain, с указанием, на основе какого поля ведется поиск.

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

    Запустив этот код, вы должны увидеть вывод, который поможет вам диагностировать проблемы с сравнением записей, особенно когда MAC пустой.

  19. User

    перепиши функцию, так что бы при "Не найдено соответствие" производился поиск используя 'equipment_name': 'Название' вместо 'mac': 'MAC адрес' для этой записи

  20. Assistant

    Для того чтобы при возникновении ситуации "Не найдено соответствие" выполнить повторный поиск, используя вместо поля mac поле equipment_name, необходимо сохранить прежнюю логику, но добавить дополнительный шаг, который будет выполнять новый поиск с использованием equipment_name. Вот как можно переписать вашу функцию:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус',
            'last_updated': 'Дата изменения статуса'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row, key='mac'):
            # Используем equipment_name вместо mac, если ключ не равен 'mac'
            key_value = row[key] if pd.notna(row[key]) else row['equipment_name']
            
            conditions = (
                (dfmain['mac'] == key_value) &
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status']) &
                (dfmain['last_updated'] == row['last_updated'])
            )
            return dfmain[conditions]
    
        # Список для хранения результатов несоответствий
        discrepancies = []
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус', 'Дата изменения статуса'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status', 'last_updated'],
            suffixes=('_change', '_main')
        )
    
        # Экспортируем объединённые данные в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}_merged.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            matches = find_matching_rows(row)
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                # Проверка на пустые значения
                if pd.isna(row['mac']) and pd.isna(row['serial_number']) and pd.isna(row['status']) and pd.isna(row['last_updated']):
                    continue  # Пропускаем, если все поля пустые
    
                # Выполняем повторный поиск с использованием 'equipment_name' вместо 'mac'
                matches_using_equipment_name = find_matching_rows(row, key='equipment_name')
    
                if matches_using_equipment_name.shape[0] > 0:
                    print(f"Найденно соответствие для записи на индексе {index} с использованием 'equipment_name':")
                    print(matches_using_equipment_name.to_dict(orient='records'))
    
                else:
                    # Если подходящих записей не найдено
                    print(f"Не найдено соответствие для записи на индексе {index}:")
                    print("Запись в dfchange:")
                    print(row.to_dict())
                    print("Записи в dfmain:")
                    print(dfmain)
                    print("\n")
                    
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'],
                        'Serial Number': row['serial_number'],
                        'Status': row['status'],
                        'Last Updated': row['last_updated'],
                        'Message': 'Не найдено соответствие'
                    })
    
                continue
            
            if matches.shape[0] > 1:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Last Updated': row['last_updated'],
                    'Message': f'Найдено {matches.shape[0]} совпадений'
                })
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Проверка на соответствие NaN
                if (pd.isna(main_value) and pd.isna(change_value)):
                    continue  # Они равны, если оба NaN
    
                # Сравнение значений и добавление в список несоответствий
                if main_value != change_value:
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'] if pd.notnull(row['mac']) else 'N/A',
                        'Serial Number': row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A',
                        'Status': row['status'] if pd.notnull(row['status']) else 'N/A',
                        'Last Updated': row['last_updated'] if pd.notnull(row['last_updated']) else 'N/A',
                        'Column': dfchange_field,
                        'Value Main': main_value,
                        'Value Change': change_value,
                        'Message': 'Несоответствие'
                    })
    
        # Сохраняем результаты несоответствий в файл
        if discrepancies:
            discrepancies_df = pd.DataFrame(discrepancies)
            discrepancies_file = f"{file_name.rsplit('.', 1)[0]}_discrepancies.xlsx"
            discrepancies_df.to_excel(discrepancies_file, index=False)
            print(f"Результаты несоответствий сохранены в файл: {discrepancies_file}")
        else:
            print("Несоответствий не найдено.")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Изменения:

    1. Условие для повторного поиска: В случае, если не найдены соответствия с использованием поля mac, выполняется дополнительный поиск с использованием equipment_name.

    2. Печать отладочной информации: При каждом случае, когда не находится соответствие, выводится информация о записи из dfchange и, если найдено совпадение с equipment_name, оно также выводится.

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

  21. User

    искать необходимо по полям в dfmain['equipment_name'] вместо 'mac': 'MAC адрес', а не в dfmain['mac']

  22. Assistant

    Извините за недопонимание. Давайте перепишем вашу функцию так, чтобы в случае, когда mac пустой (NaN), у нас было возможность производить поиск совпадений по полю dfmain['equipment_name'].

    Вот обновленный код с правильной логикой:

    import pandas as pd
    
    def compare_dataframes(dfmain, dfchange, file_name):
        # Определяем соответствие полей для сравнения
        field_mapping = {
            'rues_name': 'Подразделение',
            'ceh_name': 'Участок',
            'equipment_type_name': 'Тип',
            'equipment_name': 'Название',
            'mac': 'MAC адрес',
            'serial_number': 'Серийный номер',
            'status': 'Статус',
            'last_updated': 'Дата изменения статуса'
        }
    
        # Функция для поиска совпадений
        def find_matching_rows(row, key='mac'):
            # Возвращаем значение для условия поиска в зависимости от выбранного ключа
            key_value = row[key] if pd.notna(row[key]) else None
            
            conditions = (
                (dfmain['serial_number'] == row['serial_number']) &
                (dfmain['status'] == row['status']) &
                (dfmain['last_updated'] == row['last_updated'])
            )
            
            if key_value:
                # Если ключевое значение не пустое, добавляем условие для него
                conditions &= (dfmain[key] == key_value)
    
            return dfmain[conditions]
    
        # Список для хранения результатов несоответствий
        discrepancies = []
    
        # Объединяем DataFrame dfchange и dfmain
        merged_df = pd.merge(
            dfchange,
            dfmain,
            how='left',
            left_on=['Участок', 'MAC адрес', 'Серийный номер', 'Статус', 'Дата изменения статуса'],
            right_on=['ceh_name', 'mac', 'serial_number', 'status', 'last_updated'],
            suffixes=('_change', '_main')
        )
    
        # Экспортируем объединённые данные в Excel
        output_file = f"{file_name.rsplit('.', 1)[0]}_merged.xlsx"
        merged_df.to_excel(output_file, sheet_name='Данные', index=False)
    
        # Проверка совпадений по полям
        for index, row in merged_df.iterrows():
            matches = find_matching_rows(row, key='mac')
    
            # Проверяем количество найденных совпадений
            if matches.shape[0] == 0:
                # Проверка на пустые значения
                if pd.isna(row['mac']) and pd.isna(row['serial_number']) and pd.isna(row['status']) and pd.isna(row['last_updated']):
                    continue  # Пропускаем, если все поля пустые
    
                # Выполняем повторный поиск с использованием 'equipment_name' вместо 'mac'
                matches_using_equipment_name = find_matching_rows(row, key='equipment_name')
    
                if matches_using_equipment_name.shape[0] > 0:
                    print(f"Найденно соответствие для записи на индексе {index} с использованием 'equipment_name':")
                    print(matches_using_equipment_name.to_dict(orient='records'))
    
                else:
                    # Если подходящих записей не найдено
                    print(f"Не найдено соответствие для записи на индексе {index}:")
                    print("Запись в dfchange:")
                    print(row.to_dict())
                    print("Записи в dfmain:")
                    print(dfmain)
                    print("\n")
                    
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'],
                        'Serial Number': row['serial_number'],
                        'Status': row['status'],
                        'Last Updated': row['last_updated'],
                        'Message': 'Не найдено соответствие'
                    })
    
                continue
            
            if matches.shape[0] > 1:
                discrepancies.append({
                    'Index': index,
                    'MAC': row['mac'],
                    'Serial Number': row['serial_number'],
                    'Status': row['status'],
                    'Last Updated': row['last_updated'],
                    'Message': f'Найдено {matches.shape[0]} совпадений'
                })
    
            # Проверка значений для совпадающих строк
            for dfmain_field, dfchange_field in field_mapping.items():
                main_value = matches[dfmain_field].values[0] if matches.shape[0] > 0 else None
                change_value = row.get(dfchange_field)
    
                # Проверка на соответствие NaN
                if (pd.isna(main_value) and pd.isna(change_value)):
                    continue  # Они равны, если оба NaN
    
                # Сравнение значений и добавление в список несоответствий
                if main_value != change_value:
                    discrepancies.append({
                        'Index': index,
                        'MAC': row['mac'] if pd.notnull(row['mac']) else 'N/A',
                        'Serial Number': row['serial_number'] if pd.notnull(row['serial_number']) else 'N/A',
                        'Status': row['status'] if pd.notnull(row['status']) else 'N/A',
                        'Last Updated': row['last_updated'] if pd.notnull(row['last_updated']) else 'N/A',
                        'Column': dfchange_field,
                        'Value Main': main_value,
                        'Value Change': change_value,
                        'Message': 'Несоответствие'
                    })
    
        # Сохраняем результаты несоответствий в файл
        if discrepancies:
            discrepancies_df = pd.DataFrame(discrepancies)
            discrepancies_file = f"{file_name.rsplit('.', 1)[0]}_discrepancies.xlsx"
            discrepancies_df.to_excel(discrepancies_file, index=False)
            print(f"Результаты несоответствий сохранены в файл: {discrepancies_file}")
        else:
            print("Несоответствий не найдено.")
    
    # Пример вызова функции
    # compare_dataframes(dfmain, dfchange, "your_file_name.xlsx")
    

    Изменения:

    1. Логика поиска: Если mac пустой (NaN), функция сначала ищет совпадения, как обычно, а затем выполняет второй поиск по полю equipment_name, если совпадения не найдены.

    2. Условие для поиска совпадений: Во время первой проверки поиска find_matching_rows проверяется поле mac, во второй раз, если не найдено соответствие, используется поле equipment_name.

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

  23. User

    подскажи как вывести из df в файл уникальные 'equipment_name' для перечисленных в списке 'equipment_type_name'

  24. Assistant

    Чтобы вывести уникальные значения equipment_name из DataFrame df, соответствующие перечисленным в списке equipment_type_name, вы можете использовать метод isin() для фильтрации DataFrame, а затем метод drop_duplicates() для получения уникальных значений. После этого результаты можно сохранить в файл.

    Вот пример того, как это можно сделать:

    import pandas as pd
    
    # Пример исходного DataFrame
    data = {
        'equipment_name': ['Equipment A', 'Equipment B', 'Equipment C', 'Equipment A', 'Equipment D'],
        'equipment_type_name': ['Type 1', 'Type 2', 'Type 1', 'Type 1', 'Type 3']
    }
    df = pd.DataFrame(data)
    
    # Список типов оборудования, для которых нужно получить уникальные названия
    equipment_types_to_filter = ['Type 1', 'Type 2']
    
    # Фильтруем DataFrame по equipment_type_name и получаем уникальные equipment_name
    unique_equipment_names = df[df['equipment_type_name'].isin(equipment_types_to_filter)]['equipment_name'].drop_duplicates()
    
    # Преобразуем результат в DataFrame, если необходимо
    unique_equipment_names_df = pd.DataFrame(unique_equipment_names)
    
    # Сохраняем в файл (например, в Excel или CSV)
    output_file = 'unique_equipment_names.xlsx'  # или 'unique_equipment_names.csv' для CSV
    unique_equipment_names_df.to_excel(output_file, index=False)
    # Если хотите сохранить в CSV, используйте следующую строку:
    # unique_equipment_names_df.to_csv('unique_equipment_names.csv', index=False)
    
    print(f"Уникальные названия оборудования сохранены в файл: {output_file}")
    

    Объяснение:

    1. Фильтрация: Мы используем isin() для фильтрации строк DataFrame, где equipment_type_name содержится в вашем списке equipment_types_to_filter.

    2. Уникальные значения: Затем извлекаем только equipment_name и применяем drop_duplicates(), чтобы получить уникальные значения.

    3. Сохранение в файл: Результаты сохраняются в файл Excel или CSV в зависимости от вашего выбора.

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

  25. User

    надо две колонки на выходе 'equipment_type_name' и 'equipment_name'

  26. Assistant

    Чтобы получить два столбца на выходе — equipment_type_name и equipment_name — и вывести их в файл, вы можете адаптировать предыдущий код следующим образом:

    import pandas as pd
    
    # Пример исходного DataFrame
    data = {
        'equipment_name': ['Equipment A', 'Equipment B', 'Equipment C', 'Equipment A', 'Equipment D'],
        'equipment_type_name': ['Type 1', 'Type 2', 'Type 1', 'Type 1', 'Type 3']
    }
    df = pd.DataFrame(data)
    
    # Список типов оборудования, для которых нужно получить уникальные названия
    equipment_types_to_filter = ['Type 1', 'Type 2']
    
    # Фильтруем DataFrame по equipment_type_name
    filtered_df = df[df['equipment_type_name'].isin(equipment_types_to_filter)]
    
    # Получаем уникальные комбинации equipment_type_name и equipment_name
    unique_equipment_df = filtered_df.drop_duplicates(subset=['equipment_type_name', 'equipment_name'])
    
    # Сохраняем в файл (например, в Excel или CSV)
    output_file = 'unique_equipment_combinations.xlsx'  # или 'unique_equipment_combinations.csv' для CSV
    unique_equipment_df.to_excel(output_file, index=False)
    # Если хотите сохранить в CSV, используйте следующую строку:
    # unique_equipment_df.to_csv('unique_equipment_combinations.csv', index=False)
    
    print(f"Уникальные комбинации equipment_type_name и equipment_name сохранены в файл: {output_file}")
    

    Объяснение:

    1. Фильтрация: Мы сначала фильтруем DataFrame df, чтобы оставить только те строки, где equipment_type_name содержится в вашем списке equipment_types_to_filter.

    2. Уникальные комбинации: Затем используем drop_duplicates() с указанием subset=['equipment_type_name', 'equipment_name'], чтобы получить уникальные комбинации этих двух колонок.

    3. Сохранение в файл: Результаты сохраняются в файл Excel или CSV, в зависимости от вашего выбора.

    Это создаст выходной файл с двумя колонками: equipment_type_name и equipment_name, содержащими только уникальные комбинации.

  27. User

    как оставить только нужные столбцы

  28. Assistant

    Чтобы оставить только нужные столбцы в итоговом DataFrame перед сохранением в файл, вы можете использовать метод loc или просто индексировать DataFrame по списку нужных колонок. Я добавлю этот шаг в предыдущий пример.

    Вот обновленный код:

    import pandas as pd
    
    # Пример исходного DataFrame
    data = {
        'equipment_name': ['Equipment A', 'Equipment B', 'Equipment C', 'Equipment A', 'Equipment D'],
        'equipment_type_name': ['Type 1', 'Type 2', 'Type 1', 'Type 1', 'Type 3']
    }
    df = pd.DataFrame(data)
    
    # Список типов оборудования, для которых нужно получить уникальные названия
    equipment_types_to_filter = ['Type 1', 'Type 2']
    
    # Фильтруем DataFrame по equipment_type_name
    filtered_df = df[df['equipment_type_name'].isin(equipment_types_to_filter)]
    
    # Получаем уникальные комбинации equipment_type_name и equipment_name
    unique_equipment_df = filtered_df.drop_duplicates(subset=['equipment_type_name', 'equipment_name'])
    
    # Оставляем только нужные столбцы
    final_df = unique_equipment_df[['equipment_type_name', 'equipment_name']]
    
    # Сохраняем в файл (например, в Excel или CSV)
    output_file = 'unique_equipment_combinations.xlsx'  # или 'unique_equipment_combinations.csv' для CSV
    final_df.to_excel(output_file, index=False)
    # Если хотите сохранить в CSV, используйте следующую строку:
    # final_df.to_csv('unique_equipment_combinations.csv', index=False)
    
    print(f"Уникальные комбинации equipment_type_name и equipment_name сохранены в файл: {output_file}")
    

    Объяснение нового шага:

    1. Индексация по нужным столбцам: После того как мы получили уникальные комбинации, мы индексируем unique_equipment_df так, чтобы оставить только столбцы equipment_type_name и equipment_name, создавая новый DataFrame final_df.

    2. Сохранение в файл: Теперь мы сохраняем уже отфильтрованный DataFrame final_df, который содержит только нужные колонки.

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

  29. User

    напиши функцию, которая принимает на входе два df. df2 содержит таблицу с правильными сочетаниями колонок "Новый тип" и "Новое название". Необходимо проверить df1, что бы сочетание данных для каждой записи "Новый тип" и "Новое название" находилось в df2. результаты несовпадений вывести в файл

  30. Assistant

    Чтобы создать функцию, которая проверяет, находятся ли сочетания "Новый тип" и "Новое название" из первого DataFrame (df1) в правильных сочетаниях из второго DataFrame (df2), и записывать результаты несовпадений в файл, можно использовать следующий код:

    import pandas as pd
    
    def check_combinations(df1, df2, output_file):
        """
        Проверяет сочетания "Новый тип" и "Новое название" из df1 на наличие в df2.
        
        :param df1: DataFrame для проверки
        :param df2: DataFrame с правильными сочетаниями
        :param output_file: Путь к файлу для сохранения результатов несоответствий
        """
        # Получаем уникальные комбинации из df2
        valid_combinations = df2[['Новый тип', 'Новое название']].drop_duplicates()
    
        # Проверяем сочетания из df1 на соответствие правильным
        mismatches = df1[~df1[['Новый тип', 'Новое название']].apply(
            tuple, axis=1).isin(valid_combinations.apply(tuple, axis=1))]
    
        # Сохраняем результаты несоответствий в файл
        mismatches.to_excel(output_file, index=False)
    
        print(f"Несоответствия сохранены в файл: {output_file}")
    
    # Пример использования функции
    # Создайте df1 и df2, например:
    data1 = {
        'Новый тип': ['Тип A', 'Тип B', 'Тип C', 'Тип A'],
        'Новое название': ['Название 1', 'Название 2', 'Название 3', 'Название 1']
    }
    df1 = pd.DataFrame(data1)
    
    data2 = {
        'Новый тип': ['Тип A', 'Тип B'],
        'Новое название': ['Название 1', 'Название 2']
    }
    df2 = pd.DataFrame(data2)
    
    # Вызов функции провеирки
    check_combinations(df1, df2, 'mismatches.xlsx')
    

    Объяснение:

    1. Получение уникальных комбинаций: Мы извлекаем уникальные сочетания "Новый тип" и "Новое название" из df2, чтобы убедиться, что они являются корректными.

    2. Проверка сочетаний: С помощью метода apply и функции tuple мы создаем кортежи из каждой строки, чтобы сравнивать сочетания из df1 с уникальными сочетаниями из df2. В результате мы отбираем все записи из df1, которые не соответствуют сочетаниям в df2.

    3. Сохранение результатов: Все несовпадающие записи сохраняются в выходной файл (в данном случае в Excel).

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

  31. User

    напиши программу, которая читает df правит поле "Новое название" по шаблону с сохранением замен

  32. Assistant

    Чтобы написать программу, которая будет читать DataFrame, корректировать поле "Новое название" по определённому шаблону и сохранять все произведённые замены, можно воспользоваться библиотекой pandas и методами замены строк.

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

    Вот пример реализации:

    import pandas as pd
    
    def update_new_name(df, column_name, replacement_dict):
        """
        Обновляет значения в заданном столбце DataFrame на новые по шаблону.
        
        :param df: DataFrame для обновления
        :param column_name: Название столбца для обновления
        :param replacement_dict: Словарь с заменами (старое значение -> новое значение)
        :return: Tuple из обновленного DataFrame и DataFrame с заменами
        """
        # Копируем DataFrame для хранения замен
        replacements = []
    
        # Обновляем значения в указанном столбце
        for old_value, new_value in replacement_dict.items():
            # Заменяем значения и сохраняем результаты в список изменений
            mask = df[column_name] == old_value
            if mask.any():
                replacements.extend(df.loc[mask, [column_name]].assign(Old=old_value, New=new_value).to_dict('records'))
                df.loc[mask, column_name] = new_value
    
        # Создаем DataFrame для замены
        replacements_df = pd.DataFrame(replacements)
    
        return df, replacements_df
    
    # Пример использования функции
    data = {
        'Новый тип': ['Тип A', 'Тип B', 'Тип C', 'Тип A'],
        'Новое название': ['Старая Название 1', 'Старая Название 2', 'Старая Название 1', 'Старая Название 3']
    }
    df = pd.DataFrame(data)
    
    # Словарь замен
    replacement_dict = {
        'Старая Название 1': 'Новое Название 1',
        'Старая Название 2': 'Новое Название 2',
        'Старая Название 3': 'Новое Название 3'
    }
    
    # Обновляем DataFrame
    updated_df, replacements_df = update_new_name(df, 'Новое название', replacement_dict)
    
    # Сохраняем результаты
    updated_df.to_excel('updated_dataframe.xlsx', index=False)
    replacements_df.to_excel('replacements_log.xlsx', index=False)
    
    print("Обновлённый DataFrame сохранён в 'updated_dataframe.xlsx'")
    print("Лог замен сохранён в 'replacements_log.xlsx'")
    

    Объяснение:

    1. Функция update_new_name:

      • Эта функция принимает DataFrame, имя колонки для обновления и словарь замен.
      • Внутри функции мы проходим по словарю замен. Если находим строки, которые нужно заменить, то обновляем их и добавляем информацию о замене в список.
      • После завершения замен создаем новый DataFrame, который содержит информацию о произведенных заменах.
    2. Пример использования:

      • Создается DataFrame с двумя колонками.
      • Определяется словарь для замен, который будет использоваться в функции.
      • Обновленный DataFrame и лог замен сохраняются в файлы Excel.
    3. Сохранение результатов:

      • Оба результата (обновленный DataFrame и лог замен) сохраняются в отдельные Excel файлы.

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

  33. User

    читает из csv

  34. Assistant

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

    Вот обновленный код, который будет читать из CSV:

    import pandas as pd
    
    def update_new_name(df, column_name, replacement_dict):
        """
        Обновляет значения в заданном столбце DataFrame на новые по шаблону.
    
        :param df: DataFrame для обновления
        :param column_name: Название столбца для обновления
        :param replacement_dict: Словарь с заменами (старое значение -> новое значение)
        :return: Tuple из обновленного DataFrame и DataFrame с заменами
        """
        # Копируем DataFrame для хранения замен
        replacements = []
    
        # Обновляем значения в указанном столбце
        for old_value, new_value in replacement_dict.items():
            # Заменяем значения и сохраняем результаты в список изменений
            mask = df[column_name] == old_value
            if mask.any():
                replacements.extend(df.loc[mask, [column_name]].assign(Old=old_value, New=new_value).to_dict('records'))
                df.loc[mask, column_name] = new_value
    
        # Создаем DataFrame для замены
        replacements_df = pd.DataFrame(replacements)
    
        return df, replacements_df
    
    # Читаем DataFrame из CSV файла
    input_file = 'input_data.csv'  # Укажите путь к вашему CSV файлу
    df = pd.read_csv(input_file)
    
    # Словарь замен
    replacement_dict = {
        'Старая Название 1': 'Новое Название 1',
        'Старая Название 2': 'Новое Название 2',
        'Старая Название 3': 'Новое Название 3'
    }
    
    # Обновляем DataFrame
    updated_df, replacements_df = update_new_name(df, 'Новое название', replacement_dict)
    
    # Сохраняем результаты в CSV
    updated_df.to_csv('updated_dataframe.csv', index=False)
    replacements_df.to_csv('replacements_log.csv', index=False)
    
    print("Обновлённый DataFrame сохранён в 'updated_dataframe.csv'")
    print("Лог замен сохранён в 'replacements_log.csv'")
    

    Объяснение изменений:

    1. Чтение данных из CSV:

      • Используется pd.read_csv() для считывания данных из CSV файла. Убедитесь, что вы указали правильный путь к файлу.
    2. Сохранение результатов в CSV:

      • Обновленный DataFrame и лог замен сохраняются с использованием to_csv().

    Убедитесь:

    1. CSV файл: Убедитесь, что файл input_data.csv существует и содержит необходимые данные, включая столбец "Новое название".

    Теперь программа сможет корректировать названия в столбце "Новое название" вашего DataFrame, который был считан из CSV файла, и сохранит результаты обратно в CSV.

  35. User

    изменения не сохраняются, перепроверь код

  36. Assistant

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

    В этом примере мы будем:

    1. Считывать данные из CSV файла.
    2. Обновлять значения в заданном столбце в соответствии с шаблоном замен.
    3. Сохранять обновленный DataFrame и лог замен.

    Вот пример кода:

    import pandas as pd
    
    def update_new_name(df, column_name, replacement_dict):
        """
        Обновляет значения в заданном столбце DataFrame на новые по шаблону.
    
        :param df: DataFrame для обновления
        :param column_name: Название столбца для обновления
        :param replacement_dict: Словарь с заменами (старое значение -> новое значение)
        :return: Tuple из обновленного DataFrame и DataFrame с заменами
        """
        # Копируем DataFrame для хранения замен
        replacements = []
    
        # Обновляем значения в указанном столбце
        for old_value, new_value in replacement_dict.items():
            # Заменяем значения и сохраняем результаты в список изменений
            mask = df[column_name] == old_value
            if mask.any():
                # Сохраняем информацию о заменах
                replacements.extend(df.loc[mask, [column_name]].assign(Old=old_value, New=new_value).to_dict('records'))
                # Обновляем значение в DataFrame
                df.loc[mask, column_name] = new_value
    
        # Создаем DataFrame для замены
        replacements_df = pd.DataFrame(replacements)
    
        return df, replacements_df
    
    # Читаем DataFrame из CSV файла
    input_file = 'input_data.csv'  # Укажите путь к вашему CSV файлу
    df = pd.read_csv(input_file)
    
    # Проверим, что данные правильно считаны
    print("Исходные данные:")
    print(df)
    
    # Словарь замен
    replacement_dict = {
        'Старая Название 1': 'Новое Название 1',
        'Старая Название 2': 'Новое Название 2',
        'Старая Название 3': 'Новое Название 3'
    }
    
    # Обновляем DataFrame
    updated_df, replacements_df = update_new_name(df, 'Новое название', replacement_dict)
    
    # Сохраняем результаты в CSV
    updated_df.to_csv('updated_dataframe.csv', index=False)
    replacements_df.to_csv('replacements_log.csv', index=False)
    
    print("Обновлённый DataFrame сохранён в 'updated_dataframe.csv'")
    print("Лог замен сохранён в 'replacements_log.csv'")
    

    Что проверять:

    1. Файл input_data.csv: Убедитесь, что этот файл существует в директории, откуда запускаете скрипт, и содержит необходимые данные, а именно столбец "Новое название".

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

    3. Обновление: Все замены должны работать, как только программа их применяет.

    4. Сохранение: Обратите внимание, что метод to_csv() будет перезаписывать файл, если он существует. Убедитесь, что вы не потеряете важные данные из существующего файла updated_dataframe.csv.

    Попробуйте этот код в своей среде. Если у вас по-прежнему есть проблемы с сохранением изменений, проверьте доступность файла и права на запись в директорию.

  37. User

    вот в этом моменте updated_df, replacements_df = update_new_name(df, 'Новое название', replacement_dict) в updated_df точно обновлённый df?

  38. Assistant

    Ваша интуиция верная! В момент вызова функции update_new_name(df, 'Новое название', replacement_dict) переменная updated_df должна содержать обновленный DataFrame с новыми значениями в указанном столбце ("Новое название"). Давайте я еще раз уточню весь процесс и приведу некоторую дополнительную отладочную информацию.

    Полный код с дополнительными проверками

    import pandas as pd
    
    def update_new_name(df, column_name, replacement_dict):
        """
        Обновляет значения в заданном столбце DataFrame на новые по шаблону.
    
        :param df: DataFrame для обновления
        :param column_name: Название столбца для обновления
        :param replacement_dict: Словарь с заменами (старое значение -> новое значение)
        :return: Tuple из обновленного DataFrame и DataFrame с заменами
        """
        # Для хранения информации о замене
        replacements = []
    
        # Обновляем значения в указанном столбце
        for old_value, new_value in replacement_dict.items():
            # Заменяем значения и сохраняем результаты в список изменений
            mask = df[column_name] == old_value
            if mask.any():  # Если есть строки, которые нужно обновить
                # Сохраняем информацию о замене
                replacements.extend(df.loc[mask, [column_name]].assign(Old=old_value, New=new_value).to_dict('records'))
                # Обновляем значение в DataFrame
                df.loc[mask, column_name] = new_value
    
        # Создаем DataFrame для логирования замен
        replacements_df = pd.DataFrame(replacements)
    
        return df, replacements_df
    
    # Читаем DataFrame из CSV файла
    input_file = 'input_data.csv'  # Укажите путь к вашему CSV файлу
    df = pd.read_csv(input_file)
    
    # Проверим, что данные правильно считаны
    print("Исходные данные:")
    print(df)
    
    # Словарь замен
    replacement_dict = {
        'Старая Название 1': 'Новое Название 1',
        'Старая Название 2': 'Новое Название 2',
        'Старая Название 3': 'Новое Название 3'
    }
    
    # Обновляем DataFrame
    updated_df, replacements_df = update_new_name(df, 'Новое название', replacement_dict)
    
    # Проверим, что df действительно обновлен
    print("\nОбновленные данные:")
    print(updated_df)
    
    # Сохраняем результаты в CSV
    updated_df.to_csv('updated_dataframe.csv', index=False)
    replacements_df.to_csv('replacements_log.csv', index=False)
    
    print("Обновлённый DataFrame сохранён в 'updated_dataframe.csv'")
    print("Лог замен сохранён в 'replacements_log.csv'")
    

    Объяснение:

    1. Проверка входных данных: Убедитесь, что данные загружены правильно с помощью print(df).

    2. Замены: При выполнении не забудьте золото, чтобы убедиться, что значения в replacement_dict действительно присутствуют в столбце "Новое название".

    3. Проверка результата: После обновления данных выводится обновленный DataFrame с помощью print(updated_df), чтобы вы могли убедиться, что изменения произошли.

    4. Убедитесь в том, что замены выполнены: Если значения не были заменены, убедитесь в корректности ключей и значений в словаре замен. Убедитесь, что в вашем исходном DataFrame есть строки, которые соответствуют старым названиям.

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