Библиотека com объекта excel

Время на прочтение
6 мин

Количество просмотров 349K

Добрый день, уважаемые читатели.

В сегодняшней статье я хотел бы, как можно подробнее, рассмотреть интеграцию приложений Python и MS Excel. Данные вопрос может возникнуть, например, при создании какой-либо системы онлайн отчетности, которая должна выгружать результаты в общепринятый формат ну или какие-либо другие задачи. Также в статье я покажу и обратную интеграцию, т.е. как использовать функцию написанную на python в Excel, что также может быть полезно для автоматизации отчетов.

Работаем с файлами MS Excel на Python

Для работы с Excel файлами из Python мне известны 2 варианта:

1. Использование библиотек, таких как xlrd, xlwt, xlutils или openpyxl
2. Работа с com-объектом

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

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

Итак, первый метод довольно простой и хорошо описан. Например, есть отличная статья для описания работы c xlrd, xlwt, xlutils. Поэтому в данном материале я приведу небольшой кусок кода с их использованием.

Для начала загрузим нужные библиотеки и откроем файл xls на чтение и выберем
нужный лист с данными:

import xlrd, xlwt
#открываем файл
rb = xlrd.open_workbook('../ArticleScripts/ExcelPython/xl.xls',formatting_info=True)

#выбираем активный лист
sheet = rb.sheet_by_index(0)

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

#получаем значение первой ячейки A1
val = sheet.row_values(0)[0]

#получаем список значений из всех записей
vals = [sheet.row_values(rownum) for rownum in range(sheet.nrows)]

Как видно чтение данных не составляет труда. Теперь запишем их в другой файл. Для этого создам новый excel файл с новой рабочей книгой:

wb = xlwt.Workbook()
ws = wb.add_sheet('Test')

Запишем в новый файл полученные ранее данные и сохраним изменения:

#в A1 записываем значение из ячейки A1 прошлого файла
ws.write(0, 0, val[0])

#в столбец B запишем нашу последовательность из столбца A исходного файла
i = 0
for rec in vals:
    ws.write(i,1,rec[0])
    i =+ i

#сохраняем рабочую книгу
wb.save('../ArticleScripts/ExcelPython/xl_rec.xls')

Из примера выше видно, что библиотека xlrd отвечает за чтение данных, а xlwt — за запись, поэтому нет возможности внести изменения в уже созданную книгу без ее копирования в новую. Кроме этого указанные библиотеки работают только с файлами формата xls (Excel 2003) и у них нет поддержки нового формата xlsx (Excel 2007 и выше).

Чтобы успешно работать с форматом xlsx, понадобится библиотека openpyxl. Для демонстрации ее работы проделаем действия, которые были показаны для предыдущих библиотек.

Для начала загрузим библиотеку и выберем нужную книгу и рабочий лист:

import openpyxl
wb = openpyxl.load_workbook(filename = '../ArticleScripts/ExcelPython/openpyxl.xlsx')
sheet = wb['test']

Как видно из вышеприведенного листинга сделать это не сложно. Теперь посмотрим как можно считать данные:

#считываем значение определенной ячейки
val = sheet['A1'].value

#считываем заданный диапазон
vals = [v[0].value for v in sheet.range('A1:A2')]

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

Теперь посмотрим как нам произвести запись и сохранить данные:

#записываем значение в определенную ячейку
sheet['B1'] = val

#записываем последовательность
i = 0
for rec in vals:
    sheet.cell(row=i, column=2).value = rec
    i =+ 1

# сохраняем данные
wb.save('../ArticleScripts/ExcelPython/openpyxl.xlsx')

Из примера видно, что запись, тоже производится довольно легко. Кроме того, в коде выше, можно заметить, что openpyxl кроме имен ячеек может работать и с их индексами.

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

Как было показано выше, для более менее полноценной работы с excel файлами, в данном случае, нужно 4 библиотеки, и это не всегда удобно. Кроме этого, возможно нужен будет доступ к VBA (допустим для какой-либо последующей обработки) и с помощью этих библиотек его не получить.

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

Работа с com-объектом

В своих отчетах я предпочитаю использовать второй способ, а именно использование файла Excel через com-объект с использованием библиотеки win32com. Его преимуществом, является то, что вы можете выполнять с файлом все операции, которые позволяет делать обычный Excel с использованием VBA.

Проиллюстрируем это на той же задаче, что и предыдущие примеры.

Для начала загрузим нужную библиотеку и создадим COM объект.

import win32com.client
Excel = win32com.client.Dispatch("Excel.Application")

Теперь мы можем работать с помощью объекта Excel мы можем получить доступ ко всем возможностям VBA. Давайте, для начала, откроем любую книгу и выберем активный лист. Это можно сделать так:

wb = Excel.Workbooks.Open(u'D:\Scripts\DataScience\ArticleScripts\ExcelPython\xl.xls')
sheet = wb.ActiveSheet

Давайте получим значение первой ячейки и последовательности:

#получаем значение первой ячейки
val = sheet.Cells(1,1).value

#получаем значения цепочки A1:A2
vals = [r[0].value for r in sheet.Range("A1:A2")]

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

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

#записываем значение в определенную ячейку
sheet.Cells(1,2).value = val

#записываем последовательность
i = 1
for rec in vals:
    sheet.Cells(i,3).value = rec
    i = i + 1

#сохраняем рабочую книгу
wb.Save()

#закрываем ее
wb.Close()

#закрываем COM объект
Excel.Quit()

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

Однако, внимательный читатель, обратит внимание на переменную i, которая инициализируется не 0, как принято python, а 1. Это связано с тем, что мы работаем с индексами ячеек как из VBA, а там нумерация начинается не с 0, а с 1.

На этом закончим разбор способов работы с excel файлами в python и перейдем к обратной задаче.

Вызываем функции Python из MS Excel

Может возникнуть такая ситуация, что у вас уже есть какой-либо функция, которая обрабатывает данные на python, и нужно перенести ее функциональность в Excel. Конечно же можно переписать ее на VBA, но зачем?

Для использования функций python в Excel есть прекрасная надстройка ExcelPython. С ее помощью вы сможете вызывать функции написанные на python прямо из Excel, правда придется еще написать небольшую обертку на VBA, и все это будет показано ниже.

Итак, предположим у нас есть функция, написанная на python, которой мы хотим воспользоваться:

def get_unique(lists):
    sm = 0
    for i in lists:
        sm = sm + int(i.pop()) 
    return sm

На вход ей подается список, состоящий из списков, это одно из условий, которое должно выполняться для работы данной функции в Excel.

Сохраним функцию в файле plugin.py и положим его в ту же директорию, где будет лежать наш excel файл, с которым мы будем работать.

Теперь установим ExcelPython. Установка происходит через запуск exe-файла и не вызывает затруднений.

Когда все приготовления выполнены, открываем тестовый файл excel и вызовем редактор VBA (Alt+F11). Для работы с вышеуказанной надстройкой необходимо ее подключить, через Tools->References, как показано на рисунке:

Ну что же, теперь можно приступить к написанию функции-обертки для нашего Python-модуля plugin.py. Выглядеть она будет следующим образом:

Function sr(lists As Range)
    On Error GoTo do_error
        Set plugin = PyModule("plugin", AddPath:=ThisWorkbook.Path)
        Set result = PyCall(plugin, "get_unique", PyTuple(lists.Value2))
        sr = WorksheetFunction.Transpose(PyVar(result))
        Exit Function
do_error:
        sr = Err.Description
End Function

Итак, что же происходит в данной функции?

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

Затем, с помощью PyCall, вызываем нужную нам функцию из указанного модуля. В качестве параметров PyCall получает следующее:

1. Объект модуля, полученный на предыдущем шаге
2. Имя вызываемой функции
3. Параметры, передаваемые функции (передаются в виде списка)

Функция PyTuple, получает на вход какие-либо значения и преобразует их в объект tuple языка Python.
Ну и, соответственно, PyVar выполняет операцию преобразования результата функции python, к типу понятному Excel.

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

Как видно из рисунка все отработало правильно.

Надо отметить, что в данном материале используется старая версия ExcelPython, и на GitHub’e автора доступна новая версия.

Заключение

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

Также хочу заметить, что указанные пакеты не являются единственными и в статье опущено рассмотрение, таких пакетов как xlsxwriter для генерации excel файлов или xlwings, который может работать с Excel файлами «на лету», а также же PyXLL, который выполняет аналогичные функции ExcelPython.

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

Введение

Python имеет множество возможностей для создания стандартных типов файлов Microsoft Office^એ, включая Excel^એ, Word^એ и PowerPoint^એ. Однако в некоторых случаях может оказаться слишком сложно использовать чистый подход Python для решения проблемы. К счастью, для python есть пакет “Python for Windows Extensions” (Python для расширений Windows), известный как pywin32, который позволяет нам легко получить доступ к Component Object Model (COM), компонентной объектной модели Windows, и управлять приложениями Microsoft через python. В этой статье будут рассмотрены некоторые базовые сценарии использования этого типа автоматизации и рассказывается о том, как приступить к работе с некоторыми полезными скриптами.

С веб-сайта Microsoft о модели компонентных объектов (COM):

Платформенно-независимая распределенная объектно-ориентированная система для создания двоичных программных компонентов, которые могут взаимодействовать. COM является базовой технологией для технологий Microsoft OLE Automation^એ (составные документы) и ActiveX^એ (компоненты с доступом в Интернет). COM-объекты могут быть созданы с помощью множества языков программирования.

Эта технология позволяет нам управлять приложениями Windows из другой программы. Многие из читателей этого блога, вероятно, видели или использовали VBA^એ для некоторой автоматизации задачи Excel. COM — это основополагающая технология, поддерживающая VBA.

pywin32

Пакет pywin32 существует уже очень давно. Фактически, книга, посвященная этой теме, была опубликована в 2000 году Марком Хаммондом и Энди Робинсоном. Несмотря на то, что с тех пор уже прошло много лет (что заставляет меня чувствовать себя действительно старым), лежащие в основе технологии и концепции работают и сегодня. Pywin32 — это, по сути, очень тонкая оболочка python, которая позволяет нам взаимодействовать с COM-объектами и автоматизировать приложения Windows с помощью python. Сила этого подхода заключается в том, что вы можете делать практически все, что может делать приложение Microsoft, через python. Обратной стороной является то, что вам придется запускать это в системе Windows с установленным Microsoft Office. Прежде чем мы рассмотрим несколько примеров, убедитесь, что в вашей системе установлен pywin32 с помощью pip или conda.

Еще одна рекомендация: держите под рукой ссылку на страницу Тима Голдена. На этом ресурсе есть еще много подробностей о том, как использовать python в Windows для автоматизации и других административных задач.

Начиная

Все наши приложения начинаются с одинакового импорта и процесса активации приложения. Вот очень короткий пример открытия Excel:

import win32com.client as win32
excel = win32.gencache.EnsureDispatch('Excel.Application')

excel.Visible = True
_ = input("Press ENTER to quit:")

excel.Application.Quit()

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

Первый шаг — импортировать клиента win32. Я использовал соглашение об импорте его как win32, чтобы сделать фактический код отправки немного короче.

Магия этого кода заключается в использовании EnsureDispatch для запуска Excel. В этом примере я использую gencache.EnsureDispatch для создания статического прокси. Я рекомендую прочитать эту статью, если вы хотите узнать больше о статических и динамических прокси. Мне посчастливилось использовать этот подход для примеров, включенных в эту статью, но буду честен — я не слишком много экспериментировал с различными подходами к диспетчеризации.

Теперь, когда объект excel запущен, нам нужно явно сделать его видимым, установив excel.Visible = TrueКод.

win32 довольно умен и закроет Excel после завершения работы программы. Это означает, что если мы просто оставим код работать самостоятельно, вы, вероятно, не увидите Excel. Я включаю фиктивную подсказку, чтобы Excel оставался видимым на экране, пока пользователь не нажмет ENTER.

Я включаю последнюю строку excel.Application.Quit(), как немного ремня и подтяжек. Строго говоря, win32 должен закрыть Excel, когда программа будет завершена, но я решил включить excel.Application.Quit(), чтобы показать, как принудительно закрыть приложение.

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

Открыть файл в Excel

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

Вот полный пример:

import win32com.client as win32
import pandas as pd
from pathlib import Path

# Read in the remote data file
df = pd.read_csv("https://github.com/chris1610/pbpython/blob/master/data/sample-sales-tax.csv?raw=True")

# Define the full path for the output file
out_file = Path.cwd() / "tax_summary.xlsx"

# Do some summary calcs
# In the real world, this would likely be much more involved
df_summary = df.groupby('category')['ext price', 'Tax amount'].sum()

# Save the file as Excel
df_summary.to_excel(out_file)

# Open up Excel and make it visible
excel = win32.gencache.EnsureDispatch('Excel.Application')
excel.Visible = True

# Open up the file
excel.Workbooks.Open(out_file)

# Wait before closing it
_ = input("Press enter to close Excel")
excel.Application.Quit()

Вот результат в Excel:

Этот простой пример расширяет предыдущий, показывая, как использовать объект Workbooks для открытия файла.

Прикрепите файл Excel к Outlook

Другой простой сценарий, в котором полезен COM, — это когда вы хотите прикрепить файл к электронному письму и отправить его в список рассылки. В этом примере показано, как выполнять некоторые манипуляции с данными, открывать электронную почту Outlook,прикрепите файл и оставьте его открытым для дополнительного текста перед отправкой.

Вот полный пример:

import win32com.client as win32
import pandas as pd
from pathlib import Path
from datetime import date


to_email = """
Lincoln, Abraham <>; 
"""

cc_email = """
Franklin, Benjamin <>
"""

# Read in the remote data file
df = pd.read_csv("https://github.com/chris1610/pbpython/blob/master/data/sample-sales-tax.csv?raw=True")

# Define the full path for the output file
out_file = Path.cwd() / "tax_summary.xlsx"

# Do some summary calcs
# In the real world, this would likely be much more involved
df_summary = df.groupby('category')['ext price', 'Tax amount'].sum()

# Save the file as Excel
df_summary.to_excel(out_file)

# Open up an outlook email
outlook = win32.gencache.EnsureDispatch('Outlook.Application')
new_mail = outlook.CreateItem(0)

# Label the subject
new_mail.Subject = "{:%m/%d} Report Update".format(date.today())

# Add the to and cc list
new_mail.To = to_email
new_mail.CC = cc_email

# Attach the file
attachment1 = out_file

# The file needs to be a string not a path object
new_mail.Attachments.Add(Source=str(attachment1))

# Display the email
new_mail.Display(True)

Этот пример немного усложняется, но основные концепции те же. Нам нужно создать наш объект (в данном случае Outlook) и создать новое электронное письмо. Одним из сложных аспектов работы с COM является отсутствие согласованного API. Создание такого электронного письма не является интуитивным: new_mail = outlook.CreateItem (0) Обычно требуется немного поисков, чтобы выяснить точный API для конкретной проблемы. Google и stackoverflow — ваши друзья.

После создания объекта электронной почты вы можете добавить получателя и список CC, а также прикрепить файл. Когда все сказано и сделано, это выглядит так:

Электронное письмо открыто, и вы можете добавить дополнительную информацию и отправить ее. В этом примере я решил не закрывать Outlook и позволить python обрабатывать эти детали.

Последний пример является наиболее сложным, но иллюстрирует мощный подход к объединению анализа данных Python с пользовательским интерфейсом Excel.

С помощью pandas можно создать сложный Excel, но такой подход может быть очень трудоемким. Альтернативным подходом было бы создание сложного файла в Excel, затем выполните манипуляции с данными и скопируйте вкладку данных в окончательный вывод Excel.

Вот пример панели инструментов Excel, которую мы хотим создать:

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

Приступим к работе с кодом.

import win32com.client as win32
import pandas as pd
from pathlib import Path

# Read in the remote data file
df = pd.read_csv("https://github.com/chris1610/pbpython/blob/master/data/sample-sales-tax.csv?raw=True")

# Define the full path for the data file file
data_file = Path.cwd() / "sales_summary.xlsx"

# Define the full path for the final output file
save_file = Path.cwd() / "sales_dashboard.xlsx"

# Define the template file
template_file = Path.cwd() / "sample_dashboard_template.xlsx"

В этом разделе мы выполнили импорт, прочитали данные и определили все три файла. Следует отметить, что этот процесс включает в себя этап суммирования данных с помощью pandas и сохранения данных в файле Excel. Затем мы повторно открываем этот файл и копируем данные в шаблон. Это немного запутано, но это лучший подход, который я мог придумать для этого сценария.

Далее выполняем анализ и сохраняем временный файл Excel:

# Do some summary calcs
# In the real world, this would likely be much more involved
df_summary = df.groupby('category')['quantity', 'ext price', 'Tax amount'].sum()

# Save the file as Excel
df_summary.to_excel(data_file, sheet_name="Data")

Теперь мы используем COM, чтобы объединить временный выходной файл с нашей вкладкой панели управления Excel и сохранить новую копию:

# Use com to copy the files around
excel = win32.gencache.EnsureDispatch('Excel.Application')
excel.Visible = False
excel.DisplayAlerts = False

# Template file
wb_template = excel.Workbooks.Open(template_file)

# Open up the data file
wb_data = excel.Workbooks.Open(data_file)

# Copy from the data file (select all data in A:D columns)
wb_data.Worksheets("Data").Range("A:D").Select()

# Paste into the template file
excel.Selection.Copy(Destination=wb_template.Worksheets("Data").Range("A1"))

# Must convert the path file object to a string for the save to work
wb_template.SaveAs(str(save_file))

Код открывает Excel и удостоверяется, что его не видно. Затем он открывает шаблон панели мониторинга и файлы данных. Он использует Range("A: D").Select() для выбора всех данных, а затем копирует их в файл шаблона.

Последний шаг — сохранить шаблон как новый файл. Этот подход может быть очень удобным ярлыком, когда у вас есть ситуация, когда вы хотите использовать python для обработки данных, но вам нужен сложный вывод Excel. Возможно, сейчас у вас нет явной потребности в этом, но если вы когда-нибудь создадите сложный отчет Excel, этот подход будет намного проще, чем пытаться вручную кодировать электронную таблицу с помощью python.

Заключение

Я предпочитаю стараться как можно больше придерживаться python для повседневного анализа данных. Однако важно знать, когда другие технологии могут упростить процесс или повысить эффективность результатов. Технология Microsoft COM является зрелой технологией, и ее можно эффективно использовать через Python для выполнения задач, которые в противном случае были бы слишком сложными. Надеюсь, эта статья дала вам несколько идей о том, как включить эту технику в свой рабочий процесс. Если у вас есть какие-либо задачи, для которых вы хотите использовать pywin32, сообщите нам об этом в комментариях.

По материалам Automating Windows Applications Using COM

#Для работы потребуется:
#Python for Windows Extensions — http://sourceforge.net/projects/pywin32/files/pywin32/Build%20219/
#.NET(я использовал 4.5) — http://www.microsoft.com/ru-ru/download/details.aspx?id=30653

#Импортируем библиотеку
import win32com.client

#Создаем COM объект
Excel = win32com.client.Dispatch(«Excel.Application»)

#Получаем доступ к активному листу
wb = Excel.Workbooks.Open(u’C:\python\script.xlsx’)
sheet = wb.ActiveSheet

#Получим значение ячейки A1 активного листа
val = sheet.Cells(1,1).value
print(val)

#Получим значения диапазона A1:A2 активного листа
vals = [r[0].value for r in sheet.Range(«A1:A2»)]
print(vals)

#Запишем новое значение в ячейку A3 активного листа
sheet.Cells(3,1).value = ‘A3Value’

#Сохраним
wb.Save()

#Получаем доступ к листу — Лист2 и диапазону ячеек
sheet2 = wb.Worksheets(u’Лист2′).Range(‘A1:A2’)

#Получим значения диапазона A1:A2 Лист2
vals = [r[0].value for r in sheet2]
print(vals)

#Закроем файл
wb.Close()

#Закроем COM объект
Excel.Quit()

Комментарии пользователей

Вообще COM-объекты используют для соединения информационной базы 1С с файлом Word, Excel, Outlook или любой другой программой, поддерживающей данный интерфейс обмена данными. В этой статье рассмотрим задачу выгрузки/загрузки данных из/в MS Excel. Чтобы это осуществить воспользуемся COM-соединением и объектом Excel.Application. Для примера возьмём задачу выгрузки/загрузки данных о номенклатуре. Пример рассмотрим ниже.

COM-соединение

Что же такое COM-соединение? Component Object Model (или COM) – это технология (фирмы Microsoft) взаимодействующих компонентов, которые одновременно могут быть использованы в разных приложениях. При этом весь функционал соответствующего компонента наследуется внутрь разрабатываемого приложения. В нашем случае COM-объект Excel.Application используется внутри кода 1С для операций с файлом книги MS Excel.

Объект Excel.Application

У объекта Excel.Application существует ряд методов, которые нам могут пригодиться для реализации нижепоставленной задачи:

• ОбъектExcel.WorkBooks.Open(ИмяФайла) – Открытие книги MS Excel
  
• ОбъектExcel.ActiveWorkbook.Close() – Закрытие текущей книги
  
• ОбъектExcel.Quit() – Закрытие COM-объекта
  
• ОбъектExcel.Sheets(ИмяЛиста) – Получает лист книги
  
• ЛистExcel.Cells(НачалоСтрока, НачалоСтолбец) – Ячейка таблицы на данном листе
  
• ЛистExcel.Range(Ячейка1, Ячейка2) – Выделенная область
  
• ЯчейкаExcel.Value – Значение ячейки таблицы
  
• ЯчейкаExcel.Text – Текст ячейки таблицы
  

Постановка задачи

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

• Номенклатура
  
• Количество
  
• Цена
  
• Сумма.
  

Необходимо реализовать 2 функционала (сделать на форме 2 основные кнопки):

1. Выгрузка табличной части в подготовленный файл MS Excel
   
2. Загрузка табличной части из файла.
   

Алгоритм выгрузки/загрузки в MS Excel

Алгоритм выгрузки следующий:

1. Выгружаем табличную часть в таблицу значений
   
2. Создаём новый COM-объект Excel.Application
   
3. Выбираем файл, открываем файл книги MS Excel
   
4. Переходим на заданный лист книги
   
5. Выгружаем данные в файл
   
6. Закрываем книгу, выходим из COM-объекта.
   

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

1. Создаём новый COM-объект Excel.Application
   
2. Выбираем файл, открываем файл книги MS Excel
   
3. Переходим на заданный лист книги
   
4. Загружаем данные из файла в таблицу значений
   
5. Закрываем книгу, выходим из COM-объекта
   
6. Таблицу значений выгружаем в табличную часть.
   

Операция выгрузки и загрузки данных о номенклатуре происходит в заранее подготовленный шаблон MS Excel.

Пример кода 1С

Код 1С я постарался разделить на отдельные функции, чтобы, скопировав, с ними можно было работать где угодно. На форме обработки 1С были созданы 3 кнопки:

• Выгрузить
  
• Загрузить
  
• Очистить.
  

В итоге в реализации алгоритма получились следующие основные процедуры и функции 1С:

• ПолучитьExcel – Получает COM-объект MS Excel;
  
• ЗакрытьExcel – Закрывает использование COM-объекта MS Excel;
  
• ПолучитьЛистExcel – Получает лист книги Excel;
  
• ДобавитьТабличныйДокументВExcel – Добавляет табличный документ на лист Excel (нужно для выгрузки данных);
  
• ПрочитатьОбластьИзExcel – Читает область ячеек с листа Excel (нужно для загрузки данных);
  
• ШиринаЛистаExcel – Ширина листа Excel;
  
• ВысотаЛистаExcel – Высота листа Excel;
  
• ПреобразоватьТДвТЗ – Преобразует табличный документ в таблицу значений;
  
• ПреобразоватьТЗвТД – Преобразует таблицу значений в табличный документ;
  

Для начала приведу вспомогательную функцию для открытия/сохранения файла на диске:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#Если Клиент Тогда
// Функция выбора файла.
//
// Параметры:
// 	РежимВыбора - <РежимДиалогаВыбораФайла> - Выбор каталога, открытие или сохранение файла;
//	Расширение - <Строка>, <Массив> - Список расширений файла.
//
// Возвращаемое значение:
//	<Строка> - Путь к выбранному файлу.
//
Функция ВыбратьФайлДокумента(РежимВыбора, Расширение = "*") Экспорт
 
	ИмяФайла = "";
	//ФорматМассив = РазобратьСтрокуВМассивПоРазделителю(Расширение);
	ФорматМассив = ПреобразоватьВМассив(Расширение);
 
	ДиалогФайла = Новый ДиалогВыбораФайла(РежимВыбора);
	Если РежимВыбора = РежимДиалогаВыбораФайла.Открытие Тогда
		ДиалогФайла.Заголовок = "Открыть документ";
	ИначеЕсли РежимВыбора = РежимДиалогаВыбораФайла.Сохранение Тогда
		ДиалогФайла.Заголовок = "Сохранить документ";
	ИначеЕсли РежимВыбора = РежимДиалогаВыбораФайла.ВыборКаталога Тогда
		ДиалогФайла.Заголовок = "Выбрать каталог";
	КонецЕсли;
 
	Фильтр = "";
	Для Каждого ЭлементМассив Из ФорматМассив Цикл
		Если ЭлементМассив = "*" Тогда
			Фильтр = Фильтр + "|" + НСтр("ru = ""Все файлы""; en = ""All files""");
		ИначеЕсли ВРег(ЭлементМассив) = ВРег("TXT") Тогда
			Фильтр = Фильтр + "|" + НСтр("ru = ""Текстовый документ""; en = ""Text document""");
		ИначеЕсли ВРег(ЭлементМассив) = ВРег("MXL") Тогда
			Фильтр = Фильтр + "|" + НСтр("ru = ""Табличный документ""; en = ""Table document""");
		ИначеЕсли ВРег(ЭлементМассив) = ВРег("XLS") ИЛИ ВРег(ЭлементМассив) = ВРег("XLSX") ИЛИ ВРег(ЭлементМассив) = ВРег("XLSM") Тогда
			Фильтр = Фильтр + "|" + НСтр("ru = ""Табличный документ MS Excel""; en = ""Table document MS Excel""");
		ИначеЕсли ВРег(ЭлементМассив) = ВРег("XML") Тогда
			Фильтр = Фильтр + "|" + НСтр("ru = ""Документ XML""; en = ""Document XML""");
		ИначеЕсли ВРег(ЭлементМассив) = ВРег("HTML") ИЛИ ВРег(ЭлементМассив) = ВРег("HTM") Тогда
			Фильтр = Фильтр + "|" + НСтр("ru = ""HTML документ""; en = ""HTML document""");
		Иначе
			Фильтр = Фильтр + "|" + НСтр("ru = ""Файл " + ВРег(ЭлементМассив) + """; en = ""File " + ВРег(ЭлементМассив) + """");
		КонецЕсли;
		Фильтр = Фильтр + " (*." + НРег(ЭлементМассив) + ")|*." + НРег(ЭлементМассив);
	КонецЦикла;
	Фильтр = Сред(Фильтр, 2);
 
	ДиалогФайла.Фильтр = Фильтр;
	ДиалогФайла.МножественныйВыбор = Ложь;
 
	Если ДиалогФайла.Выбрать() Тогда
		ИмяФайла = ?(РежимВыбора = РежимДиалогаВыбораФайла.ВыборКаталога, ДиалогФайла.Каталог, ДиалогФайла.ПолноеИмяФайла);
	Иначе
		Текст = "ru = ""Файл не выбран!""; en = ""File(s) not selected!""";
		Предупреждение(НСтр(Текст));
	КонецЕсли;
 
	Возврат ИмяФайла;
КонецФункции	
#КонецЕсли

Также в реализации алгоритма были задействованы следующие вспомогательные функции:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// Преобразует в массив переменную любого типа данных.
//
// Параметры:
//	Объект - Произвольный - произвольный объект данных;
//	Проверка - <Булево> - Осуществление проверки на заполненное значение.
//
// Возвращаемое значение:
//	<Массив> - Массив с теми же данными.
//
Функция ПреобразоватьВМассив(Объект, Проверка = Ложь) Экспорт
 
	ОбъектМассив = Новый Массив;
 
	Если НЕ Проверка ИЛИ ЗначениеЗаполнено(Объект) Тогда
		Если ТипЗнч(Объект) = Тип("Массив") Тогда
			ОбъектМассив = Объект;
		ИначеЕсли ТипЗнч(Объект) = Тип("СписокЗначений") Тогда
			ОбъектМассив = Объект.ВыгрузитьЗначения();
		ИначеЕсли ТипЗнч(Объект) = Тип("Строка") Тогда
			ОбъектМассив = РазобратьСтрокуВМассивПоРазделителю(Объект);
		ИначеЕсли ТипЗнч(Объект) = Тип("Структура") Тогда
			Для Каждого Элемент Из Объект Цикл
				ОбъектМассив.Добавить(Элемент.Значение);
			КонецЦикла;
		Иначе
			ОбъектМассив.Добавить(Объект);
		КонецЕсли;
	КонецЕсли;
 
	Возврат ОбъектМассив;
КонецФункции;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// Разбирает строку в массив подстрок по разделителю. 
// При этом пробелы между подстроками не учитываются.
//
// Параметры:
//	Стр - исходная строка;
//	СтрРазделитель - разделитель, по умолчанию ",";
//	ИгнорироватьПустые - игнорировать ли пустые места между разделителями.
//
// Возвращаемое значение:
//	Массив строк
//
Функция РазобратьСтрокуВМассивПоРазделителю(Знач Стр, СтрРазделитель = ",", ИгнорироватьПустые = Ложь) Экспорт
 
	Результат = Новый Массив;
 
	ВхождениеРазделителя = Найти(Стр, СтрРазделитель);
	Пока ВхождениеРазделителя <> 0 Цикл
		ЧастьДоРазделителя = СокрЛП(Лев(Стр, ВхождениеРазделителя - 1));
		Если НЕ (ИгнорироватьПустые И ПустаяСтрока(ЧастьДоРазделителя)) Тогда
			Результат.Добавить(ЧастьДоРазделителя);
		КонецЕсли;
		Стр = СокрЛП(Сред(Стр, ВхождениеРазделителя + 1));
		ВхождениеРазделителя = Найти(Стр, СтрРазделитель);
	КонецЦикла;
 
	Если НЕ (ИгнорироватьПустые И ПустаяСтрока(Стр)) Тогда
		Результат.Добавить(СокрЛП(Стр));
	КонецЕсли;
 
	Возврат Результат;	
КонецФункции;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// Создаёт новую таблицу значений с заданными колонками.
//
// Параметры:
//	пКолонки - <Строка>, <Структура>, <Массив>, <СписокЗначений>, <ТаблицаЗначений> - 
//	 Набор колонок для таблицы значений.
//	
// Возвращаемое значение:
//	<ТаблицаЗначений> - Созданная таблица.
//
Функция ПолучитьТаблицуВывода(пКолонки) Экспорт
 
	ТЗ = Новый ТаблицаЗначений;
 
	Если пКолонки <> Неопределено Тогда 
 
		Если ТипЗнч(пКолонки) = Тип("Строка") Тогда
			пКолонки = РазобратьСтрокуВМассивПоРазделителю(пКолонки);
		КонецЕсли;
 
		Если ТипЗнч(пКолонки) = Тип("Структура") Тогда
			Для Каждого Поле Из пКолонки Цикл	
				СтрокаТабл = ТЗ.Колонки.Добавить(Поле.Ключ, Поле.Значение);	
			КонецЦикла;
		ИначеЕсли ТипЗнч(пКолонки) = Тип("СписокЗначений") Тогда
			Для Каждого Поле Из пКолонки Цикл	
				Если Поле.Пометка Тогда
					СтрокаТабл = ТЗ.Колонки.Добавить(Поле.Значение, пКолонки.ТипЗначения, Поле.Представление);
				КонецЕсли;
			КонецЦикла;
		ИначеЕсли ТипЗнч(пКолонки) = Тип("ТаблицаЗначений") Тогда
			ЕстьНаименование = (пКолонки.Колонки.Найти("Наименование") <> Неопределено);
			ЕстьТипЗначения = (пКолонки.Колонки.Найти("ТипЗначения") <> Неопределено);
			ЕстьЗаголовок = (пКолонки.Колонки.Найти("Заголовок") <> Неопределено);
			ЕстьШирина = (пКолонки.Колонки.Найти("Ширина") <> Неопределено);
			Для Каждого Поле Из пКолонки Цикл
				СтрокаТабл = ТЗ.Колонки.Добавить(?(ЕстьНаименование, Поле.Наименование, ""), ?(ЕстьТипЗначения, Поле.ТипЗначения, Новый ОписаниеТипов), ?(ЕстьЗаголовок, Поле.Заголовок, ""), ?(ЕстьШирина, Поле.Ширина, 0));	
			КонецЦикла;
		Иначе
			Для Каждого Поле Из пКолонки Цикл	
				СтрокаТабл = ТЗ.Колонки.Добавить(Поле);	
			КонецЦикла;
		КонецЕсли;
 
	КонецЕсли;
 
	Возврат ТЗ;	
КонецФункции;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Создаёт структуру колонок из таблицы значений.
//
// Параметры:
//	ТабЗначений - <ТаблицаЗначений> - Любая таблица.
//	
// Возвращаемое значение:
//	<Структура> - Созданная таблица.
//
Функция ПолучитьСтруктуруКолонокИзТаблицы(ТабЗначений) Экспорт
 
	СтруктураКолонок = Новый Структура;
	Для Каждого ЭлементКолонка Из ТабЗначений.Колонки Цикл
		СтруктураКолонок.Вставить(ЭлементКолонка.Имя, ЭлементКолонка.ТипЗначения);
	КонецЦикла;
 
	Возврат СтруктураКолонок;
КонецФункции;

Основные функции обработки алгоритма следующие:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// Получает объект файла MS Excel.
//
// Параметры:
//	ИмяФайла - <Строка> - Путь к файлу XLS.
//	
// Возвращаемое значение:
//	<COMОбъект> - Полученный объект. Если объект не найден, то возвращается "Неопределено".
//
Функция ПолучитьExcel(ИмяФайла) Экспорт
 
	ФайлНаДиске = Новый Файл(ИмяФайла);
 
	Excel = Неопределено;
	Если нРег(ФайлНаДиске.Расширение) = ".xls" 
	 ИЛИ нРег(ФайлНаДиске.Расширение) = ".xlsx"
	 ИЛИ нРег(ФайлНаДиске.Расширение) = ".xlsm"
	Тогда
 
		Если НЕ ФайлНаДиске.Существует() Тогда
			Сообщить("Файл не существует!", СтатусСообщения.Внимание);
			Возврат Неопределено;
		КонецЕсли;
 
		Попытка
			Excel = Новый COMОбъект("Excel.Application");
			Excel.WorkBooks.Open(ИмяФайла);
		Исключение
			Сообщить("Не удалось инициализировать Excel!", СтатусСообщения.Внимание);
			Возврат Неопределено;
		КонецПопытки;
 
	КонецЕсли;	
 
	Возврат Excel;
КонецФункции;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Закрывает файл MS Excel.
//
// Параметры:
//	Excel - <COMОбъект> - Объект файла MS Excel;
//	Сохранить - <Булево> - Указывает сохранять файл при закрытии или нет. По умолчанию
//	 пользователю предлагается выбрать это самому.
//
Процедура ЗакрытьExcel(Excel, Сохранить = Неопределено) Экспорт
 
	Попытка
		#Если Клиент Тогда
		Состояние("Закрытие файла Microsoft Excel...");
		#КонецЕсли
		Если Сохранить = Неопределено Тогда
			Excel.ActiveWorkbook.Close();
		Иначе
			Excel.ActiveWorkbook.Close(Сохранить);
		КонецЕсли;
		Excel.Quit();
	Исключение
		Сообщить("Ошибка закрытия Excel!", СтатусСообщения.Внимание);
	КонецПопытки;
 
	Excel = Неопределено;	
КонецПроцедуры;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Получает лист из файла книги MS Excel.
//
// Параметры:
//	Excel - <COMОбъект> - Объект файла MS Excel;
//	ИмяЛиста - <Строка> - Имя листа книги MS Excel.
//	
// Возвращаемое значение:
//	<COMОбъект> - Полученный лист. Если объект не найден, то возвращается "Неопределено".
//
Функция ПолучитьЛистExcel(Excel, ИмяЛиста) Экспорт
 
	Попытка
		ExcelЛист = Excel.Sheets(ИмяЛиста);
	Исключение
		Сообщить("Не удалось прочитать лист Excel!", СтатусСообщения.Внимание);
		Возврат Неопределено;
	КонецПопытки;
 
	Возврат ExcelЛист;	
КонецФункции;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

// Записывает данные из табличного документа в файл MS Excel.
//
// Параметры:
//	ЛистExcel - <COMОбъект> - Лист из файла MS Excel;
//	Таблица - <ТабличныйДокумент> - Документ, по порядку следования колонок и строк 
//	 соответствующий листу файла MS Excel;
//	Шапка - <Число> - Количество первых строк для шапки в файле MS Excel;
//	СписокСтолбцов - <Строка>, <Массив> - Список номеров столбцов, которые будут выгружены 
//	 в файл MS Excel;
//	СписокСтрокЗапрета - <Строка>, <Массив> - Список номеров строк, которые не должны
//	 выгружаться в файл MS Excel. Если этот параметр не задан, то выгружаются все строки;
//	ПроверятьЗначения - <Булево> - Определяет будут ли проверяться ячейки табличного 
//	 документа на содержание в них значения, а не текстовое представление этого значения. 
//	 По умолчанию этот параметр "Ложь".
//
Процедура ДобавитьТабличныйДокументВExcel(ЛистExcel, Таблица, Шапка, СписокСтолбцов, СписокСтрокЗапрета = Неопределено, ПроверятьЗначения = Ложь) Экспорт
 
	Если ТипЗнч(СписокСтолбцов) = Тип("Строка") Тогда
		СписокСтолбцов = РазобратьСтрокуВМассивПоРазделителю(СписокСтолбцов);
	КонецЕсли;
	Если ТипЗнч(СписокСтрокЗапрета) = Тип("Строка") Тогда
		СписокСтрокЗапрета = РазобратьСтрокуВМассивПоРазделителю(СписокСтрокЗапрета);
	КонецЕсли;
 
	ЕстьМассив = (СписокСтрокЗапрета = Неопределено);
	Если ЕстьМассив Тогда
		Попытка
			МассивCOM = Новый COMSafeArray("VT_VARIANT", 1, Таблица.ВысотаТаблицы - Шапка);
		Исключение
			ЕстьМассив = Ложь;
		КонецПопытки;
	КонецЕсли;
 
	Для Каждого НомерСтолбца Из СписокСтолбцов Цикл
 
		Для НомерСтроки = Шапка+1 По Таблица.ВысотаТаблицы Цикл 
 
			Если СписокСтрокЗапрета = Неопределено 
				ИЛИ (СписокСтрокЗапрета.Найти(Строка(НомерСтроки)) = Неопределено И СписокСтрокЗапрета.Найти(Число(НомерСтроки)) = Неопределено) 
			Тогда
				Область = Таблица.Область(НомерСтроки, Число(НомерСтолбца));
				Значение = ?(ПроверятьЗначения И Область.СодержитЗначение, Область.Значение, Область.Текст);
				Если ЕстьМассив Тогда
					МассивCOM.SetValue(0, НомерСтроки-Шапка-1, Значение);
				Иначе
					ЛистExcel.Cells(НомерСтроки, Число(НомерСтолбца)).Value = Значение;
				КонецЕсли;
			КонецЕсли;
 
		КонецЦикла;
 
		Если ЕстьМассив Тогда 
			ЛистExcel.Range(ЛистExcel.Cells(Шапка+1, Число(НомерСтолбца)), ЛистExcel.Cells(Таблица.ВысотаТаблицы, Число(НомерСтолбца))).Value = МассивCOM;
		КонецЕсли;
 
	КонецЦикла;
 
КонецПроцедуры;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

// Читает область ячеек из MS Excel в табличный документ.
//
// Параметры:
//	ЛистExcel - <COMОбъект> - Лист из файла MS Excel;
//	ТабДок - <ТабличныйДокумент> - Исходный табличный документ, поле табличного 
//	 документа или таблица значений. Если этот параметр не задан, то создаётся
//	 новый табличный документ;
//	НачалоСтрока - <Число> - Начальная строка в файле MS Excel;
//	НачалоСтолбец - <Число> - Начальный столбец в файле MS Excel;
//	КонецСтрока - <Число> - Конечная строка в файле MS Excel;
//	КонецСтолбец - <Число> - Конечный столбец в файле MS Excel.
//	
// Возвращаемое значение:
//	<ТабличныйДокумент> - Возвращает прочитанный из области в MS Excel табличный 
//	 документ, который передавался в эту функцию параметром "ТабДок".
//
Функция ПрочитатьОбластьИзExcel(ЛистExcel, ТабДок = Неопределено, НачалоСтрока, НачалоСтолбец, КонецСтрока, КонецСтолбец) Экспорт
 
	Если ТабДок = Неопределено Тогда
		ТабДок = Новый ТабличныйДокумент;
	КонецЕсли;
 
	Попытка
		МассивCOM = Новый COMSafeArray("VT_VARIANT", КонецСтолбец - НачалоСтолбец + 1, КонецСтрока - НачалоСтрока + 1);
		ЕстьМассив = Истина;
	Исключение
		ЕстьМассив = Ложь;
	КонецПопытки;
 
	Если ЕстьМассив Тогда
		МассивCOM = ЛистExcel.Range(ЛистExcel.Cells(НачалоСтрока, НачалоСтолбец), ЛистExcel.Cells(КонецСтрока, КонецСтолбец)).Value;
 
		Для ИндексКолонка = НачалоСтолбец По КонецСтолбец Цикл
			Для ИндексСтрока = НачалоСтрока По КонецСтрока Цикл
				Значение = МассивCOM.GetValue(ИндексКолонка - НачалоСтолбец + 1, ИндексСтрока - НачалоСтрока + 1);
				ТабДок.Область(ИндексСтрока, ИндексКолонка).СодержитЗначение = Истина;
				ТабДок.Область(ИндексСтрока, ИндексКолонка).Значение = Значение;
			КонецЦикла;
		КонецЦикла;	
	Иначе
		Для ИндексКолонка = НачалоСтолбец По КонецСтолбец Цикл
			Для ИндексСтрока = НачалоСтрока По КонецСтрока Цикл
				Значение = ЛистExcel.Cells(ИндексСтрока, ИндексКолонка).Value;
				ТабДок.Область(ИндексСтрока, ИндексКолонка).СодержитЗначение = Истина;
				ТабДок.Область(ИндексСтрока, ИндексКолонка).Значение = Значение;
			КонецЦикла;
		КонецЦикла;
	КонецЕсли;
 
	Возврат ТабДок;
КонецФункции;

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Определяет ширину листа MS Excel.
//
// Параметры:
//	ЛистExcel - <COMОбъект> - Лист из файла MS Excel.
//	
// Возвращаемое значение:
//	<Число> - Количество столбцов в таблице.
//
Функция ШиринаЛистаExcel(ЛистExcel) Экспорт
 
	ЕстьЗащита = ЛистExcel.ProtectContents;
	Возврат ?(ЕстьЗащита, ЛистExcel.UsedRange.Columns.Count, ЛистExcel.Cells.SpecialCells(11).Column);
 
КонецФункции;

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Определяет высоту листа MS Excel.
//
// Параметры:
//	ЛистExcel - <COMОбъект> - Лист из файла MS Excel.
//	
// Возвращаемое значение:
//	<Число> - Количество строк в таблице.
//
Функция ВысотаЛистаExcel(ЛистExcel) Экспорт
 
	ЕстьЗащита = ЛистExcel.ProtectContents;
	Возврат ?(ЕстьЗащита, ЛистExcel.UsedRange.Rows.Count, ЛистExcel.Cells.SpecialCells(11).Row);
 
КонецФункции;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// Преобразовать табличный документ в таблицу значений.
//
// Параметры:
//	ТабДок - <ТабличныйДокумент> - Исходный табличный документ;
//	СтруктураКолонок - <Структура>, <ТаблицаЗначений> - Структура колонок;
//	НачалоСтрока - <Число> - Строка начала области;
//	НачалоСтолбец - <Число> - Столбец начала области;
//	КонецСтрока - <Число> - Строка конца области;
//	КонецСтолбец - <Число> - Столбец конца области.
//	
// Возвращаемое значение:
//	<ТаблицаЗначений> - Полученная таблица значений.
//
Функция ПреобразоватьТДвТЗ(ТабДок, СтруктураКолонок, Знач НачалоСтрока = Неопределено, Знач НачалоСтолбец = Неопределено, Знач КонецСтрока = Неопределено, Знач КонецСтолбец = Неопределено) Экспорт
 
	// Определение габаритов таблицы
	Если НачалоСтрока = Неопределено И НачалоСтолбец = Неопределено Тогда
		НачалоСтрока = 1;
		НачалоСтолбец = 1;
	КонецЕсли;
 
	Если НачалоСтрока = Неопределено Тогда
		НачалоСтрока = 1;
		Пока НЕ ТабДок.Область(НачалоСтрока, НачалоСтолбец).СодержитЗначение 
		 И НачалоСтрока < ТабДок.ВысотаТаблицы 
		Цикл
			НачалоСтрока = НачалоСтрока + 1;
		КонецЦикла;
	ИначеЕсли НачалоСтолбец = Неопределено Тогда
		НачалоСтолбец = 1;
		Пока НЕ ТабДок.Область(НачалоСтрока, НачалоСтолбец).СодержитЗначение 
		 И НачалоСтолбец < ТабДок.ШиринаТаблицы
		Цикл
			НачалоСтолбец = НачалоСтолбец + 1;
		КонецЦикла;
	КонецЕсли;
 
	КонецСтрока = ?(КонецСтрока = Неопределено, ТабДок.ВысотаТаблицы, КонецСтрока);
	КонецСтолбец = ?(КонецСтолбец = Неопределено, ТабДок.ШиринаТаблицы, КонецСтолбец);
 
	// Преобразование
	ЭтоТаблица = (ТипЗнч(СтруктураКолонок) = Тип("ТаблицаЗначений"));
	ТабЗначений = ПолучитьТаблицуВывода(СтруктураКолонок);
 
	Для ИндексСтроки = НачалоСтрока По КонецСтрока Цикл
		СтрокаТЗ = ТабЗначений.Добавить();
 
		ИндексКолонки = НачалоСтолбец;
		Для Каждого Колонка Из СтруктураКолонок Цикл
			НаименованиеКолонки = ?(ЭтоТаблица, Колонка.Наименование, Колонка.Ключ);
			пИндексКолонки = ?(ЭтоТаблица, Колонка.СтолбецОтчёт, ИндексКолонки);
 
			Если ТабДок.Область(ИндексСтроки, пИндексКолонки).СодержитЗначение Тогда
				СтрокаТЗ[НаименованиеКолонки] = ТабДок.Область(ИндексСтроки, пИндексКолонки).Значение;
			Иначе
				СтрокаТЗ[НаименованиеКолонки] = ТабДок.Область(ИндексСтроки, пИндексКолонки).Текст;
			КонецЕсли;
 
			ИндексКолонки = ИндексКолонки + 1;
		КонецЦикла;
	КонецЦикла;
 
	Возврат ТабЗначений;
КонецФункции;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// Преобразовать таблицу значений в табличный документ.
//
// Параметры:
//	ТабЗначений - <ТаблицаЗначений> - Исходная таблица значений;
//	ТабДок - <ТабличныйДокумент> - Полученный табличный документ. Если параметр не задан, 
//	 то документ создаётся заново и возвращается функцией;
//	НачалоСтрока - <Число> - Строка начала области;
//	НачалоСтолбец - <Число> - Столбец начала области;
//	ВыводитьЗаголовки - <Булево> - Определяет выводить ли имена колонок или нет.
//	
// Возвращаемое значение:
//	<ТабличныйДокумент> - Полученный табличный документ (возвращает параметр "ТабДок").
//
Функция ПреобразоватьТЗвТД(ТабЗначений, ТабДок = Неопределено, Знач НачалоСтрока = Неопределено, Знач НачалоСтолбец = Неопределено, ВыводитьЗаголовки = Ложь) Экспорт
 
	Если ТабДок = Неопределено Тогда
		ТабДок = Новый ТабличныйДокумент;
	КонецЕсли;
 
	// Определение габаритов таблицы
	НачалоСтрока = ?(НачалоСтрока = Неопределено, 1, НачалоСтрока);
	НачалоСтолбец = ?(НачалоСтолбец = Неопределено, 1, НачалоСтолбец);
 
	// Преобразование
	ИндексСтроки = НачалоСтрока;
	Если ВыводитьЗаголовки Тогда
		ИндексКолонки = НачалоСтолбец;
		Для Каждого Колонка Из ТабЗначений.Колонки Цикл
			ТабДок.Область(ИндексСтроки, ИндексКолонки).Текст = ?(ПустаяСтрока(Колонка.Заголовок), Колонка.Имя, Колонка.Заголовок);
			ИндексКолонки = ИндексКолонки + 1;
		КонецЦикла;
		ИндексСтроки = ИндексСтроки + 1;
	КонецЕсли;
 
	Для Каждого Элемент Из ТабЗначений Цикл
		ИндексКолонки = НачалоСтолбец;
		Для Каждого Колонка Из ТабЗначений.Колонки Цикл
			ТабДок.Область(ИндексСтроки, ИндексКолонки).СодержитЗначение = Истина;
			ТабДок.Область(ИндексСтроки, ИндексКолонки).ТипЗначения = Новый ОписаниеТипов(Колонка.ТипЗначения);
			ТабДок.Область(ИндексСтроки, ИндексКолонки).Значение = Элемент[Колонка.Имя];
			ИндексКолонки = ИндексКолонки + 1;
		КонецЦикла;
		ИндексСтроки = ИндексСтроки + 1;
	КонецЦикла;
 
	Возврат ТабДок;
КонецФункции;

В реализации алгоритма был дополнительно использован объект COMSafeArray с типом VT_VARIANT. Этот COM-объект выступает в качестве двумерного массива, в котором удобно хранить значения ячеек. Также использование данного объекта повышает быстродействие операций чтения/записи для ячеек таблицы.

Целиком получившуюся обработку 1С, а также шаблон для загрузки/выгрузки можно скачать по ссылке ниже.

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

Introduction

A non-programmer amateur
To let Python do the boring things
It is a memorandum when considering pywin32.

Since it is a confirmation with a narrow usage range and a low usage frequency,
There may be mistakes or misunderstandings in the description.
Please refer to the following contents at your own risk.

Named and optional arguments

The method argument is
Similar to C ++ default arguments
It seems that it is not possible to omit the argument in the middle.

The site that I used as a reference for pywin32 (win32com)

How to operate Excel from pywin32 using COM
https://sites.google.com/site/pythoncasestudy/home/pywin32kara-comwo-tsuka-tsu-te-excelwo-sousa-suru-houhou
Operate Excel from Python with win32com
https://qiita.com/kumarstack55/items/9ae3432446afca06497f
Operate Excel (pywin32: win32com)
https://excel-ubara.com/python/python025.html

The site that I used as a reference for Excel VBA

The essence of excel
https://excel-ubara.com/
Instructor’s storybook
https://www.relief.jp/
Office TANAKA — Excel VBA
http://officetanaka.net/excel/vba/
Yone’s Word and Excel small room
http://www.eurus.dti.ne.jp/~yoneyama/

Excel operation memorandum with pywin32 (win32com) of Python

# coding:utf-8
import os
import win32com.client
import win32con
import win32gui

def main():

    # ------------------------------------------------------------------
    #Set Excel constants
    # ------------------------------------------------------------------
    # https://excel-ubara.com/EXCEL/EXCEL905.html
    # https://docs.microsoft.com/en-us/office/vba/api/excel(enumerations)
    # https://docs.microsoft.com/ja-jp/office/vba/api/excel(enumerations)
    # ------------------------------------------------------------------
    #There seems to be a way to get Excel constants.
    # https://wacky.hatenadiary.com/entry/20091011/1255240572
    # ------------------------------------------------------------------
    # Excel Enum Constants
    # ------------------------------------------------------------------
    xlAbove       =  0
    xlBelow       =  1
    xlSolid       =  1
    xlFirst       =  0
    xlLast        =  1
    xlLastCell    = 11
    xlTopToBottom =  1
    xlLeftToRight =  2
    xlGeneral     =  1
    xlAutomatic   = -4105
    xlFormats     = -4122
    xlNone        = -4142
    xlCenter      = -4108
    xlDistributed = -4117
    xlJustify     = -4130
    xlBottom      = -4107
    xlLeft        = -4131
    xlRight       = -4152
    xlTop         = -4160
    xlRTL         = -5004
    xlLTR         = -5003
    xlContext     = -5002
    # ------------------------------------------------------------------
    # Excel Enum XlAutoFillType
    # ------------------------------------------------------------------
    xlFillDefault  =  0
    xlFillCopy     =  1
    xlFillSeries   =  2
    xlFillFormats  =  3
    xlFillValues   =  4
    xlFillDays     =  5
    xlFillWeekdays =  6
    xlFillMonths   =  7
    xlFillYears    =  8
    xlLinearTrend  =  9
    xlGrowthTrend  = 10
    xlFlashFill    = 11
    # ------------------------------------------------------------------
    # Excel Enum XlAutoFilterOperator
    # ------------------------------------------------------------------
    xlAnd             =  1
    xlOr              =  2
    xlTop10Items      =  3
    xlBottom10Items   =  4
    xlTop10Percent    =  5
    xlBottom10Percent =  6
    xlFilterValues    =  7
    xlFilterCellColor =  8
    xlFilterFontColor =  9
    xlFilterIcon      = 10
    xlFilterDynamic   = 11
    # ------------------------------------------------------------------
    # Excel Enum XLBordersIndex
    # ------------------------------------------------------------------
    xlDiagonalDown     =  5
    xlDiagonalUp       =  6
    xlEdgeLeft         =  7
    xlEdgeTop          =  8
    xlEdgeBottom       =  9
    xlEdgeRight        = 10
    xlInsideHorizontal = 12
    xlInsideVertical   = 11
    # ------------------------------------------------------------------
    # Excel Enum XLBorderWeight
    # ------------------------------------------------------------------
    xlHairline = 1
    xlThin     = 2
    xlThick    = 4
    xlMedium   = -4138
    # ------------------------------------------------------------------
    # Excel Enum XlCellType
    # ------------------------------------------------------------------
    xlCellTypeConstants            =  2
    xlCellTypeBlanks               =  4
    xlCellTypeLastCell             = 11
    xlCellTypeVisible              = 12
    xlCellTypeFormulas             = -4123
    xlCellTypeComments             = -4144
    xlCellTypeAllFormatConditions  = -4172
    xlCellTypeSameFormatConditions = -4173
    xlCellTypeAllValidation        = -4174
    xlCellTypeSameValidation       = -4175
    # ------------------------------------------------------------------
    # Excel Enum XlColorIndex
    # ------------------------------------------------------------------
    xlColorIndexAutomatic = -4105
    xlColorIndexNone      = -4142
    # ------------------------------------------------------------------
    # Excel Enum XlCutCopyMode
    # ------------------------------------------------------------------
    xlCopy = 1
    xlCut  = 2
    # ------------------------------------------------------------------
    # Excel Enum XlDeleteShiftDirection
    # Excel Enum XlInsertShiftDirection
    # ------------------------------------------------------------------
    xlShiftUp      = -4162
    xlShiftDown    = -4121
    xlShiftToLeft  = -4159
    xlShiftToRight = -4161
    # ------------------------------------------------------------------
    # Excel Enum XlDirection
    # ------------------------------------------------------------------
    xlUp      = -4162
    xlDown    = -4121
    xlToLeft  = -4159
    xlToRight = -4161
    # ------------------------------------------------------------------
    # Excel Enum XlFileFormat
    # ------------------------------------------------------------------
    xlCSV                         =  6
    xlHtml                        = 44
    xlWorkbookDefault             = 51
    xlOpenXMLWorkbook             = 51
    xlOpenXMLWorkbookMacroEnabled = 52
    xlWorkbookNormal              = -4143
    xlCurrentPlatformText         = -4158
    # ------------------------------------------------------------------
    # Excel Enum XlFixedFormatType
    # ------------------------------------------------------------------
    xlTypePDF = 0
    xlTypeXPS = 1
    # ------------------------------------------------------------------
    # Excel Enum XlFixedFormatQuality
    # ------------------------------------------------------------------
    xlQualityStandard = 0
    xlQualityMinimum  = 1
    # ------------------------------------------------------------------
    # Excel Enum XlFindLookIn
    # ------------------------------------------------------------------
    xlFormulas = -4123
    xlComments = -4144
    xlValues   = -4163
    # ------------------------------------------------------------------
    # Excel Enum XlLineStyle
    # ------------------------------------------------------------------
    xlContinuous    =  1
    xlDashDot       =  4
    xlDashDotDot    =  5
    xlSlantDashDot  = 13
    xlDash          = -4115
    xldot           = -4118
    xlDouble        = -4119
    xlLineStyleNone = -4142
    # ------------------------------------------------------------------
    # Excel Enum XlOrientation
    # ------------------------------------------------------------------
    xlHorizontal = -4128
    xlVertical   = -4166
    xlDownward   = -4170
    xlUpward     = -4171
    # ------------------------------------------------------------------
    # Excel Enum XlPasteType
    # ------------------------------------------------------------------
    xlPasteValues                       = -4163
    xlPasteComments                     = -4144
    xlPasteFormulas                     = -4123
    xlPasteFormats                      = -4122
    xlPasteAll                          = -4104
    xlPasteValidation                   =  6
    xlPasteAllExceptBorders             =  7
    xlPasteColumnWidths                 =  8
    xlPasteFormulasAndNumberFormats     = 11
    xlPasteValuesAndNumberFormats       = 12
    xlPasteAllUsingSourceTheme          = 13
    xlPasteAllMergingConditionalFormats = 14
    # ------------------------------------------------------------------
    # Excel Enum XlSheetVisibility
    # ------------------------------------------------------------------
    xlSheetVisible    = -1
    xlSheetHidden     =  0
    xlSheetVeryHidden =  2
    # ------------------------------------------------------------------
    # Excel Enum XlSpecialCellsValue
    # ------------------------------------------------------------------
    xlNumbers    =  1
    xlTextValues =  2
    xlLogical    =  4
    xlErrors     = 16
    # ------------------------------------------------------------------
    # Excel Enum XlSortDataOption
    # ------------------------------------------------------------------
    xlSortNormal        = 0
    xlSortTextAsNumbers = 1
    # ------------------------------------------------------------------
    # Excel Enum XlSortMethod
    # ------------------------------------------------------------------
    xlPinYin = 1
    xlStroke = 2
    # ------------------------------------------------------------------
    # Excel Enum XlSortOrder
    # ------------------------------------------------------------------
    xlAscending  = 1
    xlDescending = 2
    xlManual     = -4135
    # ------------------------------------------------------------------
    # Excel Enum XlSortOrientation
    # ------------------------------------------------------------------
    xlSortColumns = 1
    xlSortRows    = 2
    # ------------------------------------------------------------------
    # Excel Enum XlSortOn
    # ------------------------------------------------------------------
    xlSortOnValues    = 0
    xlSortOnCellColor = 1
    xlSortOnFontColor = 2
    xlSortOnIcon      = 3
    # ------------------------------------------------------------------
    # Excel Enum XlSortType
    # ------------------------------------------------------------------
    xlSortValues  = 1
    xlSortLabels  = 2
    # ------------------------------------------------------------------
    # Excel Enum XlUnderlineStyle
    # ------------------------------------------------------------------
    xlUnderlineStyleNone             = -4142
    xlUnderlineStyleDouble           = -4119
    xlUnderlineStyleSingle           = 2 
    xlUnderlineStyleSingleAccounting = 4
    xlUnderlineStyleDoubleAccounting = 5
    # ------------------------------------------------------------------
    # Excel Enum XlYesNoGuess
    # ------------------------------------------------------------------
    xlGuess = 0
    xlYes   = 1
    xlNo    = 2
    # ------------------------------------------------------------------

    #Start Excel
    xlApp = win32com.client.Dispatch("Excel.Application")

    # https://stackoverflow.com/questions/2790825/
    #Excel Window Maximization
    win32gui.ShowWindow(xlApp.hwnd, win32con.SW_MAXIMIZE)

    #Excel display
    xlApp.Visible = 1

    #Excel file open
    wb = xlApp.Workbooks.Open(f"{os.getcwd()}\sample.csv")

    #Excel sheet object
    ws = wb.Worksheets(1)

    # ------------------------------------------------------------------

    #Select the specified sheet
    # Select()Activate the sheet before using()Is necessary
    ws.Activate()

    # ------------------------------------------------------------------

    #Select cell A1
    ws.Range("A1").Select()

    #Select A1 to B2
    ws.Range("A1:B2").Select()

    #Select A1, B2, C3 and D4
    ws.Range("A1,B2,C3,D4").Select()

    #Select A1 to B2 and C3 to D4
    ws.Range("A1:B2,C3:D4").Select()

    # ------------------------------------------------------------------

    #Select cell A1
    ws.Cells(1, 1).Select()

    #Select A1 to B2
    ws.Range(
        ws.Cells(1, 1),
        ws.Cells(2, 2)
    ).Select()

    # ------------------------------------------------------------------

    #Select all cells
    ws.Cells.Select()

    # ------------------------------------------------------------------

    #Select 1-2 lines
    ws.Range("1:2").Select()

    #Select columns A to B
    ws.Range("A:B").Select()

    # https://www.relief.jp/docs/excel-vba-difference-range-rows-columns.html
    #Select 1-2 lines
    ws.Rows("1:2").Select()

    # https://www.relief.jp/docs/excel-vba-difference-range-columns.html
    #Select columns A to B
    ws.Columns("A:B").Select()

    # ------------------------------------------------------------------

    #Select the first line of the specified range
    ws.Range("A1:D4").Rows(1).Select()

    #Select the first column of the specified range
    ws.Range("A1:D4").Columns(1).Select()

    # ------------------------------------------------------------------

    # (Based on A1 cell)Select entire line
    ws.Range("A1").EntireRow.Select()

    # (Based on A1 cell)Select entire column
    ws.Range("A1").EntireColumn.Select()

    # ------------------------------------------------------------------

    # (Based on A1 cell)Select the row up to the last column
    ws.Range(
        ws.Range("A1"),
        ws.Cells(1, ws.Columns.Count).End(xlToLeft)
    ).Select()

    # (Based on A1 cell)Select columns up to the last row
    ws.Range(
        ws.Range("A1"),
        ws.Cells(ws.Rows.Count, 1).End(xlUp)
    ).Select()

    # ------------------------------------------------------------------

    # (Based on A1 cell)Select current area
    ws.Range("A1").CurrentRegion.Select()

    # (Of the current sheet)Select the area in use
    ws.UsedRange.Select()

    # (Based on A1 cell)Final lower right cell selection
    ws.Range("A1").SpecialCells(xlLastCell).Select()

    # (Based on A1 cell)Visible state cell selection
    ws.Range("A1").CurrentRegion.SpecialCells(xlCellTypeVisible).Select()

    # ------------------------------------------------------------------

    # https://thecodingforums.com/threads/328174/
    # Range.Offset()Get Offset for Property()Method
    #Offset the specified range
    ws.Range("A1:D4").GetOffset(2, 2).Select()

    # Range.Offset()Get Offset for Property()Method
    #Offset the specified range
    ws.Range("A1:D4").GetOffset(RowOffset = 3, ColumnOffset = 3).Select()

    # Range.Offset()Get Offset for Property()Method
    #Offset the specified range vertically
    ws.Range("A1:D4").GetOffset(RowOffset = 3).Select()

    # Range.Offset()Get Offset for Property()Method
    #Offset the specified range horizontally
    ws.Range("A1:D4").GetOffset(RowOffset = 0, ColumnOffset = 3).Select()

    # ------------------------------------------------------------------

    # https://stackoverflow.com/questions/63112880/
    # Range.Resize()Get Resize for Property()Method
    #Resize the specified range
    ws.Range("A1:H8").GetResize(2, 2).Select()

    # Range.Resize()Get Resize for Property()Method
    #Resize the specified range
    ws.Range("A1:H8").GetResize(RowSize = 3, ColumnSize = 3).Select()

    # Range.Resize()Get Resize for Property()Method
    #Resize the vertical direction of the specified range
    ws.Range("A1:H8").GetResize(RowSize = 3).Select()

    # Range.Resize()Get Resize for Property()Method
    #Resize the horizontal direction of the specified range
    ws.Range("A1:H8").GetResize(RowSize = ws.Range("A1:H8").Rows.Count, ColumnSize = 3).Select()

    # ------------------------------------------------------------------

    #Get the number of rows in the specified cell
    n = ws.Range("A1").Row
    print( n )

    #Get the number of columns in the specified cell
    n = ws.Range("A1").Column
    print( n )

    #Get the number of lines included in the specified range
    n = ws.Range("A1:D4").Rows.Count
    print( n )

    #Get the number of columns included in the specified range
    n = ws.Range("A1:D4").Columns.Count
    print( n )

    # (Based on A1 cell)Get the number of last lines
    n = ws.Cells(ws.Rows.Count, 1).End(xlUp).Row
    print( n )

    # (Based on A1 cell)Get the number of last columns
    n = ws.Cells(1, ws.Columns.Count).End(xlToLeft).Column
    print( n )

    # ------------------------------------------------------------------

    # https://binary-star.net/excel-vba-columnchange
    #Convert a string of numbers to a string of letters
    a = (xlApp.ActiveWorkBook.ActiveSheet.Cells(1, 1).Address).split("$")[1]
    print( a )
    a = (xlApp.ActiveWorkBook.ActiveSheet.Cells(1, 2).Address).split("$")[1]
    print( a )
    a = (xlApp.ActiveWorkBook.ActiveSheet.Cells(1, 3).Address).split("$")[1]
    print( a )
    a = (xlApp.ActiveWorkBook.ActiveSheet.Cells(1, 27).Address).split("$")[1]
    print( a )
    a = (xlApp.ActiveWorkBook.ActiveSheet.Cells(1, 53).Address).split("$")[1]
    print( a )
    #Convert alphabetic strings to numeric strings
    n = xlApp.ActiveWorkBook.ActiveSheet.Cells(1, "A").Column
    print( n )
    n = xlApp.ActiveWorkBook.ActiveSheet.Cells(1, "B").Column
    print( n )
    n = xlApp.ActiveWorkBook.ActiveSheet.Cells(1, "C").Column
    print( n )
    n = xlApp.ActiveWorkBook.ActiveSheet.Cells(1, "AA").Column
    print( n )
    n = xlApp.ActiveWorkBook.ActiveSheet.Cells(1, "BA").Column
    print( n )

    # ------------------------------------------------------------------

    #Set value in cell A1
    ws.Range("A1").Value = 99999

    #Set formula in cell A1
    ws.Range("A1").Formula = "=(3.14159-3)*100000"

    # ------------------------------------------------------------------

    #Set the display format of cell A1
    ws.Range("A1").NumberFormatLocal = "0.00"

    # ------------------------------------------------------------------

    #Set the vertical position of A1 cell placement
    ws.Range("A1").VerticalAlignment = xlCenter

    #Set the horizontal position of A1 cell placement
    ws.Range("A1").HorizontalAlignment = xlCenter

    #Set the direction of the character string in cell A1
    ws.Range("A1").Orientation = xlUpward

    #Set the direction of the character string in cell A1
    ws.Range("A1").Orientation = 45

    #Set the direction of the character string in cell A1
    ws.Range("A1").Orientation = 0

    # ------------------------------------------------------------------

    #Set font in cell A1
    ws.Range("A1").Font.Name = "Yu Gothic UI"

    #Set font size for cell A1
    ws.Range("A1").Font.Size = 12

    #Set the font of cell A1 to bold
    ws.Range("A1").Font.Bold = True

    #Set font in cell A1 to italics
    ws.Range("A1").Font.Italic = True

    #Underline the font in cell A1
    ws.Range("A1").Font.Underline = xlUnderlineStyleSingle

    #Set strikethrough for A1 cell font
    ws.Range("A1").Font.Strikethrough = True

    # ------------------------------------------------------------------

    #Set the text color of cell A1(R+Gx256+Bx256x256)
    ws.Range("A1").Font.Color = 255 + 0*256 + 0*256*256

    #Set the text color of cell A1(Specified order BGR)
    ws.Range("A1").Font.Color = int("FF0000",16)

    #Set the text color of cell A1(Specified order RGB)
    ws.Range("A1").Font.Color = int("".join(list(reversed(["FF0000"[i: i+2] for i in range(0, 6, 2)]))),16)

    #Set the text color of cell A1(Default)
    ws.Range("A1").Font.ColorIndex = xlColorIndexAutomatic

    # ------------------------------------------------------------------

    #Set the background color of cell A1(R+Gx256+Bx256x256)
    ws.Range("A1").Interior.Color = 255 + 255*256 + 0*256*256

    #Set the background color of cell A1(Specified order BGR)
    ws.Range("A1").Interior.Color = int("FFFF00",16)

    #Set the background color of cell A1(Specified order RGB)
    ws.Range("A1").Interior.Color = int("".join(list(reversed(["FFFF00"[i: i+2] for i in range(0, 6, 2)]))),16)

    #Set the background color of cell A1(Default)
    ws.Range("A1").Interior.ColorIndex = xlColorIndexNone

    # ------------------------------------------------------------------

    #Set a ruled line in cell A1
    ws.Range("A1").Borders.Color = int("".join(list(reversed(["FF0000"[i: i+2] for i in range(0, 6, 2)]))),16)
    ws.Range("A1").Borders.LineStyle = xlContinuous
    ws.Range("A1").Borders.Weight = xlMedium

    #Remove the border of cell A1
    ws.Range("A1").Borders.LineStyle = xlLineStyleNone

    #Set a ruled line at the bottom of cell A1
    ws.Range("A1").Borders(xlEdgeBottom).Color = int("".join(list(reversed(["FF0000"[i: i+2] for i in range(0, 6, 2)]))),16)
    ws.Range("A1").Borders(xlEdgeBottom).LineStyle = xlContinuous
    ws.Range("A1").Borders(xlEdgeBottom).Weight = xlMedium

    #Remove the ruled line at the bottom of cell A1
    ws.Range("A1").Borders(xlEdgeBottom).LineStyle = xlLineStyleNone

    # ------------------------------------------------------------------

    #Clear values and formulas in cell A1
    ws.Range("A1").ClearContents()

    #Erase A1 cell format
    ws.Range("A1").ClearFormats()

    #Erase cell A1
    ws.Range("A1").Clear()

    #Delete cell A1
    ws.Range("A1").Delete()

    #Delete cell A1(Shift upwards)
    ws.Range("A1").Delete(xlShiftUp)

    #Delete cell A1(Shift to the left)
    ws.Range("A1").Delete(xlShiftToLeft)

    #Insert in cell A1
    ws.Range("A1").Insert()

    #Insert in cell A1(Shift down)
    ws.Range("A1").Insert(xlShiftDown)

    #Insert in cell A1(Shift to the right)
    ws.Range("A1").Insert(xlShiftToRight)

    # ------------------------------------------------------------------

    # (A1 line standard)Set height
    ws.Range("A1").RowHeight = 30

    # (Based on A1 column)Set width
    ws.Range("A1").ColumnWidth = 30

    # (A1 line standard)Automatic height adjustment
    ws.Range("A1").EntireRow.AutoFit()

    # (Based on A1 column)Width is automatically adjusted
    ws.Range("A1").EntireColumn.AutoFit()

    # ------------------------------------------------------------------

    #How to show and hide individual groups
    # https://vbabeginner.net/%e3%82%b0%e3%83%ab%e3%83%bc%e3%83%97%e5%8c%96%e3%81%ae%e8%a1%a8%e7%a4%ba%e3%81%a8%e9%9d%9e%e8%a1%a8%e7%a4%ba/

    #Set row grouping
    ws.Range("A1").EntireRow.Group()

    #Hide row grouping
    ws.Outline.ShowLevels(RowLevels = 1)

    #Show row grouping
    ws.Outline.ShowLevels(RowLevels = 8)

    #Ungroup rows
    ws.Range("A1").EntireRow.Ungroup()

    #Set column grouping
    ws.Range("A1").EntireColumn.Group()

    #Hide column grouping
    ws.Outline.ShowLevels(RowLevels = 0, ColumnLevels = 1)

    #Show column grouping
    ws.Outline.ShowLevels(RowLevels = 0, ColumnLevels = 8)

    #Ungroup columns
    ws.Range("A1").EntireColumn.Ungroup()

    # ------------------------------------------------------------------

    #Copy cell A1 to cell B1
    ws.Range("A1").Copy(ws.Range("B1"))

    #Copy cell A1 to cell A1 of Sheet2
    ws.Range("A1").Copy(wb.Worksheets("Sheet2").Range("A1"))

    #Copy the current area of A1 cell reference to Sheet2 A1 cell reference
    ws.Range("A1").CurrentRegion.Copy(wb.Worksheets("Sheet2").Range("A1"))

    #Copy cell A1 to clipboard
    ws.Range("A1").Copy()

    #Copy clipboard to cell B2
    ws.Activate()
    ws.Range("B2").Select()
    ws.Paste()

    #Copy clipboard to cell C3(Paste value)
    ws.Range("C3").PasteSpecial(xlPasteValues)

    #Copy clipboard to cell C3(Paste format)
    ws.Range("C3").PasteSpecial(xlPasteFormats)

    #Copy clipboard to cell C3(Paste formula)
    ws.Range("C3").PasteSpecial(xlPasteFormulas)

    #Cancel cut mode or copy mode
    xlApp.CutCopyMode = False

    # ------------------------------------------------------------------

    #Move cell A1 to cell B1
    ws.Range("A1").Cut(ws.Range("B1"))

    #Move cell A1 to cell A1 of Sheet2
    ws.Range("A1").Cut(wb.Worksheets("Sheet2").Range("A1"))

    #Move cell A1 to clipboard
    ws.Range("A1").Cut()

    #Cancel cut mode or copy mode
    xlApp.CutCopyMode = False

    # ------------------------------------------------------------------

    #Batch copy the contents of the left column of the range A1 to D4 to the range
    ws.Range("A1:D4").FillRight()

    #Batch copy the contents of the upper line in the range of E1 to H4 to the range
    ws.Range("E1:H4").FillDown()

    #Batch copy the contents of the right column in the range of A5 to D8 to the range
    ws.Range("A5:D8").FillLeft()

    #Batch copy the contents of the lower line in the range of E5 to H8 to the range
    ws.Range("E5:H8").FillUp()

    # ------------------------------------------------------------------

    #AutoFill from A1 to H1 to A1 to H8
    ws.Range("A1:H1").AutoFill(ws.Range("A1:H8"))

    #AutoFill the range from A1 to H2 to the range from A1 to H8
    ws.Range("A1:H2").AutoFill(ws.Range("A1:H8"), xlFillDefault)

    # ------------------------------------------------------------------

    #AutoFilter the current area relative to the A1 cell
    ws.Range("A1").CurrentRegion.AutoFilter()
    ws.Range("A1").CurrentRegion.AutoFilter(Field = 1, Criteria1 = ">30")

    #AutoFilter the current area relative to the A1 cell
    ws.Range("A1").CurrentRegion.AutoFilter()
    ws.Range("A1").CurrentRegion.AutoFilter(Field = 1, Criteria1 = ">30", Operator = xlAnd, Criteria2 = "<80")

    #AutoFilter the current area relative to the A1 cell
    ws.Range("A1").CurrentRegion.AutoFilter()
    ws.Range("A1").CurrentRegion.AutoFilter(1, ">30")

    #AutoFilter the current area relative to the A1 cell
    ws.Range("A1").CurrentRegion.AutoFilter()
    ws.Range("A1").CurrentRegion.AutoFilter(1, ">30", xlAnd, "<80")

    #AutoFilter the current area relative to the A1 cell
    ws.Range("A1").CurrentRegion.AutoFilter()
    ws.Range("A1").CurrentRegion.AutoFilter(1, ">30", xlAnd, "<80")
    ws.Range("A1").CurrentRegion.AutoFilter(2, ">40", xlAnd, "<60")

    #Select the range of AutoFilter
    ws.AutoFilter.Range.Select()

    #Visible cell selection in the range of AutoFilter
    ws.AutoFilter.Range.SpecialCells(xlCellTypeVisible).Select()

    #Number of visible cell rows in AutoFilter range
    n = int(ws.AutoFilter.Range.SpecialCells(xlCellTypeVisible).Count / ws.AutoFilter.Range.SpecialCells(xlCellTypeVisible).Columns.Count)
    print( n )

    #Applying AutoFilter
    ws.AutoFilter.ApplyFilter()

    #Unfiltering AutoFilter
    if ws.FilterMode:
        ws.ShowAllData()

    #Cancel AutoFilter
    if ws.AutoFilterMode:
        ws.AutoFilterMode = False

    # ------------------------------------------------------------------

    #Sort current area based on A1 cell( Range Sort Method )
    #If Type is omitted, the specification of Order2 etc. after Type is ignored.
    #If Type is set to None, no error will occur, but it will malfunction.
    ws.Activate()
    ws.Range("A1").CurrentRegion.Select()
    ws.Range("A1").CurrentRegion.Sort(
        Key1 = ws.Range("A1"), Order1 = xlDescending,
        Key2 = ws.Range("B1"), 
        Type = None,
                               Order2 = xlDescending,
        Key3 = ws.Range("C1"), Order3 = xlAscending,
        Header = xlYes,
        MatchCase = False,
        Orientation = xlSortColumns,
        SortMethod = xlPinYin,
        DataOption1 = xlSortNormal, 
        DataOption2 = xlSortNormal, 
        DataOption3 = xlSortNormal, 
    )

    #Sort current area based on A1 cell( Sort Object )
    #Although optional in Microsoft's VBA reference,
    #Note that if omitted, it may not be sorted normally.
    ws.Activate()
    ws.Range("A1").CurrentRegion.Select()
    ws.Sort.SortFields.Clear()
    ws.Sort.SortFields.Add(Key = ws.Range("A1"), SortOn = xlSortOnValues, DataOption = xlSortNormal, Order = xlAscending)
    ws.Sort.SortFields.Add(Key = ws.Range("B1"), SortOn = xlSortOnValues, DataOption = xlSortNormal, Order = xlAscending)
    ws.Sort.SortFields.Add(Key = ws.Range("C1"), SortOn = xlSortOnValues, DataOption = xlSortNormal, Order = xlDescending)
    ws.Sort.SetRange(            ws.Range("A1").CurrentRegion)
    ws.Sort.Header = xlYes
    ws.Sort.MatchCase = False
    ws.Sort.Orientation = xlSortColumns
    ws.Sort.SortMethod = xlPinYin
    ws.Sort.Apply()

    # ------------------------------------------------------------------

    #Sort after performing AutoFilter( Sort Object )
    #Although optional in Microsoft's VBA reference,
    #Note that if omitted, it may not be sorted normally.
    ws.Activate()
    ws.Range("A1").CurrentRegion.Select()
    ws.Range("A1").CurrentRegion.AutoFilter()
    ws.Range("A1").CurrentRegion.AutoFilter(1, ">30", xlAnd, "<80")
    ws.AutoFilter.Sort.SortFields.Clear()
    ws.AutoFilter.Sort.SortFields.Add(Key = ws.Range("A1"), SortOn = xlSortOnValues, DataOption = xlSortNormal, Order = xlDescending)
    ws.AutoFilter.Sort.SortFields.Add(Key = ws.Range("B1"), SortOn = xlSortOnValues, DataOption = xlSortNormal, Order = xlDescending)
    ws.AutoFilter.Sort.SortFields.Add(Key = ws.Range("C1"), SortOn = xlSortOnValues, DataOption = xlSortNormal, Order = xlAscending)
   #ws.AutoFilter.Sort.SetRange()
    ws.AutoFilter.Sort.Header = xlYes
    ws.AutoFilter.Sort.MatchCase = False
    ws.AutoFilter.Sort.Orientation = xlSortColumns
    ws.AutoFilter.Sort.SortMethod = xlPinYin
    ws.AutoFilter.Sort.Apply()

    # ------------------------------------------------------------------

    #Hide sheet
    ws.Visible = xlSheetHidden

    #Display of sheet
    ws.Visible = xlSheetVisible

    # ------------------------------------------------------------------

    #Sheet protection settings
    ws.Protect()

    #Release of sheet protection
    ws.Unprotect()

    #Set protection of sheet with password
    ws.Protect(Password = "hoge")

    #Remove password protection for sheet
    ws.Unprotect(Password = "hoge")

    # ------------------------------------------------------------------

    #Book protection settings
    wb.Protect()

    #Unprotecting the book
    wb.Unprotect()

    #Protect your workbook with a password
    wb.Protect(Password = "hoge")

    #Remove password protection for workbooks
    wb.Unprotect(Password = "hoge")

    # ------------------------------------------------------------------

    #Zoom magnification setting
    ws.Activate()
    ws.Range("A1").Select()
    xlApp.ActiveWindow.Zoom = 90

    # ------------------------------------------------------------------

    # https://stackoverflow.com/questions/43146073/
    #Fixing the frame
    ws.Activate()
    ws.Range("C3").Select()
    xlApp.ActiveWindow.FreezePanes = True

    # ------------------------------------------------------------------

    # https://qiita.com/Tachy_Pochy/items/64fe16ec076c52556b2d
    # CTRL+HOME (Sorry when using AutoFilter)
    ws.Activate()
    ws.Range("A1").Select()
    xlCtrlHomeRow    = int(xlApp.ActiveWindow.SplitRow)    + int(xlApp.ActiveWindow.Panes(1).ScrollRow)    if (1 < xlApp.ActiveWindow.Panes.Count) else 1
    xlCtrlHomeColumn = int(xlApp.ActiveWindow.SplitColumn) + int(xlApp.ActiveWindow.Panes(1).ScrollColumn) if (1 < xlApp.ActiveWindow.Panes.Count) else 1
    ws.Cells(xlCtrlHomeRow, xlCtrlHomeColumn).Select()

    # https://excel-ubara.com/excelvba4/EXCEL272.html
    # CTRL+HOME-like A1 cell selection
    ws.Activate()
    ws.Range("A1").Select()
    xlApp.Goto(ws.Range("A1"), True)

    # ------------------------------------------------------------------

    #Recalculation
    xlApp.Calculate()

    #Stop displaying Excel warning messages
    xlApp.DisplayAlerts = False

    #Start displaying Excel warning messages
    xlApp.DisplayAlerts = True

    #Stop updating the Excel screen
    xlApp.ScreenUpdating = False

    #Start updating the Excel screen
    xlApp.ScreenUpdating = True

    # ------------------------------------------------------------------

    #Change the name of the sheet
    wb.Worksheets("Sheet2").Name = "Sheet9"

    #Add sheet
    xlApp.Worksheets.Add()

    #Copy of sheet(Copy before the designated sheet)
    ws.Copy(Before = wb.Worksheets("Sheet9"))

    # https://stackoverflow.com/questions/52685699/
    #Copy of sheet(Copy after designated sheet)
    ws.Copy(Before = None, After = wb.Worksheets("Sheet9"))

    #Moving the seat(Move to the front of the specified sheet)
    ws.Move(Before = wb.Worksheets("Sheet9"))

    # https://stackoverflow.com/questions/52685699/
    #Moving the seat(Move after the specified sheet)
    ws.Move(Before = None, After = wb.Worksheets("Sheet9"))

    #Delete sheet
    wb.Worksheets("Sheet9").Delete()

    # ------------------------------------------------------------------

    #PDF output sheet
    ws.ExportAsFixedFormat(Type = xlTypePDF, Quality = xlQualityStandard, Filename = f"{os.getcwd()}\output.pdf")

    # ------------------------------------------------------------------

    #Save the workbook to a file
    wb.Save()

    #Save the workbook to an XLSX file
    wb.SaveAs(f"{os.getcwd()}\outputSaveAs.xlsx", FileFormat = xlOpenXMLWorkbook)

    #Save workbook to XLS file
    wb.SaveAs(f"{os.getcwd()}\outputSaveAs.xls", FileFormat = xlWorkbookNormal)

    #Save the workbook to a CSV file
    wb.SaveAs(f"{os.getcwd()}\outputSaveAs.csv", FileFormat = xlCSV)

    # ------------------------------------------------------------------

    #Close the book
    wb.Close()

    #Close without saving the book
    wb.Close(SaveChanges = False)

    # ------------------------------------------------------------------

    #Excel exit
    xlApp.Quit()

    # ------------------------------------------------------------------

if __name__ == "__main__":
    main()

Excel operation memorandum sample with pywin32 (win32com) of Python

sample.py
sample.csv

Обычно, если вы ходите создать CLR библиотеку для какого-либо компонента самостоятельно, то вам нужно использовать утилиту Tlbimp.exe, но для использования компонентов Office этого делать не нужно. Все необходимые библиотеки уже устанавливаются вместе с продуктом. Нам достаточно только добавить нужную сборку в проект.

Раз

И добавить соответствующую строку using в ваш код

using Excel = Microsoft.Office.Interop.Excel;

В качестве источника данных для примера будем использовать список массивов строк ( List<string[]>). В коде я написал комментарии, которые, думаю, будут вполне понятно объяснять что происходит.

 
            //Missing представляет собой отcутствующий объект, для передачи в качестве не используемого параметра.
            //В принципе, начиная с C# 4.0 можно использовать стандартный синтаксис для

            //необязательных параметров. А можно по старинке, вместо отсутствующего

            // параметра передать Missing.Value
            System.Reflection.Missing missingValue = System.Reflection.Missing.Value;

            //создаем и инициализируем объекты Excel
            Excel.Application App;
            Excel.Workbook xlsWB;
            Excel.Worksheet xlsSheet;

            App = new Microsoft.Office.Interop.Excel.Application();
            //добавляем в файл Excel книгу. Параметр в данной функции - используемый для создания книги шаблон.
            //если нас устраивает вид по умолчанию, то можно спокойно передавать пустой параметр.
            xlsWB = App.Workbooks.Add(missingValue);
            //и использует из нее
            xlsSheet = (Excel.Worksheet)xlsWB.Worksheets.get_Item(1);

            List<string[]> rows = new List<string[]>();
            rows.Add(new string[] {"1","2","3","4"});
            rows.Add(new string[] {"5","6","7","8"});
            rows.Add(new string[] {"9","10","11","12"});
            for (int i = 0; i < rows.Count; i++)
            {
                for (int j = 0; j < rows[i].Length; j++)
                {
                    xlsSheet.Cells[i + 1, j + 1] = rows[i][j];
                }
            }

            //у SaveAs масса  параметров, некоторые из которых могут оказаться для вас полезными. 
            //Сейчас мы используем только тип формата Excel12 (Excel 97) и права доступа.
            //Полное описание что и как смотрите на MSDN: 
            // http://msdn.microsoft.com/ru-ru/library/microsoft.office.tools.excel.workbook.saveas.aspx
            xlsWB.SaveAs(@"C:excel_text.xls", 
                         Excel.XlFileFormat.xlExcel12, 
                         missingValue, 
                         missingValue, 
                         missingValue, 
                         missingValue, 
                         Excel.XlSaveAsAccessMode.xlNoChange, 
                         missingValue, 
                         missingValue, 
                         missingValue, 
                         missingValue, 
                         missingValue);         
            //закрываем книгу                                                                        
            xlsWB.Close(true, missingValue, missingValue);
            //закрываем приложение
            App.Quit();  
            //уменьшаем счетчики ссылок на COM объекты, что, по идее должно их освободить.
            //почему это не произойдет - читайте ниже ;)
            System.Runtime.InteropServices.Marshal.ReleaseComObject(xlsSheet);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(xlsWB);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(App); 

Ну и пара нюансов с которыми вы можете столкнуться. В случае, если в COM-компоненте происходит исключение, которое вы не обработаете, то, как и положено, весть домен приложения будет аварийно закрыт. Вместе с RCW. В результате чего, COM-объект так и останется висеть в памяти. То есть, вполне реально получить вот такую картинку:

И нюанс второй. Код сверху не совсем правильный. Дело в том, что работая с COM Interop нужно быть предельно внимательным и осторожным, потому, что случайно можно создать COM-объект, совершенно об этом не подозревая. В данном случае, создается даже не один «случайный» объект, а несколько.
Во-первых, в строке  xlsWB = App.Workbooks.Add(missingValue); создается объект App.Workbooks, который не присваевается переменной и, соответственно, не освобожается дл тех пор, пока не выгрузится домен приложения.
Во-вторых, такая же проблема в строке в строке: xlsSheet = (Excel.Worksheet)xlsWB.Worksheets.get_Item(1);

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

 
            //создаем и инициализируем объекты Excel
            Excel.Application App;
            //переменная для Workbooks
            Excel.Workbooks xlsWBs;
            Excel.Workbook xlsWB;
            //переменная для Sheets
            Excel.Sheets xlsSheets;
            Excel.Worksheet xlsSheet;

            App = new Microsoft.Office.Interop.Excel.ApplicationClass();
            //добавляем в файл Excel книгу. Параметр в данной функции - используемый для создания книги шаблон.
            //если нас устраивает вид по умолчанию, то можно спокойно передавать пустой параметр.
            xlsWBs = App.Workbooks;
            xlsWB = xlsWBs.Add(missingValue);
            xlsSheets = xlsWB.Worksheets;
            xlsSheet = (Excel.Worksheet)xlsSheets.get_Item(1);

Ну и добавить освобождение этих переменных в конце с помощью System.Runtime.InteropServices.Marshal.ReleaseComObject.
Вообще же, работая с COM объектами старайтесь придерживаться простого правила:
Никогда не используйте больше одной точки с COM.

Microsoft Excel is widely used in almost every industry. Its intuitive interface and ease of use for organising data, performing calculations, and analysis of data sets has led to it being commonly used in countless different fields globally.

Whether you’re a fan of Excel or not, at some point you will have to deal with it! For many applications you won’t want to do complex calculations or manage large data sets in Excel itself, but you may need to take values from Excel as inputs, produce reports in an Excel format, or provide tools to Excel users. Python can be a better choice for complex tasks and fortunately there are many tools for the Python developer to work with so Excel and Python can be used together.

This post gives an overview of some of the most popular and useful tools out there to help you choose which is the right one for your specific application.

Below there’s a feature matrix outlining the different features of the packages for calling Python from Excel.

• Building Interactive Python tools with Excel as a front-end
  • PyXLL – The Python Excel Add-In
  • pywin32, win32com and comtypes
  • xlwings
  • DataNitro
• Reading and writing Excel workbooks
  • OpenPyXL
  • XlsxWriter
  • XLTable
  • Pandas
  • xlrd and xlwt
  • pyexcel
• Additional Resources

Building Interactive Python Tools with Excel as a Front-End

Excel is a well known and really good user interface for many tasks. When you get into more complex tasks and processing larger datasets however you can soon reach the limits of what can sensibly be achieved in Excel. Python is a popular choice for data science and other disciplines as it can handle these complex cases far better than Excel alone. By using both together and recognising the strengths of each, it’s possible for you to build really powerful interactive tools using Excel as a user-friendly front end, with all the heavy lifting done in Python.

Python is an extremely powerful language with an extensive ecosystem of 3rd party libraries. Leveraging Python in Excel spreadsheets can be a fantastic way to enhance your productivity and remove the need for importing and exporting data into and out of Excel. Interactive worksheets can be developed using Python code in the same way as you might use VBA, but with all of the advantages of Python.

There are a few tools available that can be used to bring Python to Excel and it can be difficult to know which one is right for different situations. Below is an overview of each, which I hope will highlight the differences between them and help you decide which ones are right for what you need to achieve.

See the table of features along with the packages that support them below.

PyXLL – The Python Excel Add-In

PyXLL is currently the only package that enables developers to write fully featured Excel addins in Python. It embeds the Python interpreter into Excel so that it can be used as a complete VBA replacement. You can think of it conceptually as being similar to something like Excel-DNA for C#, except that it is dynamic and imports your Python code while Excel is running – so there’s no add-in to build and no need to restart Excel when modifying your Python code.

See PyXLL’s Features

Using PyXLL, you can write Python code to create:

• Worksheet functions (user defined functions, called from Excel worksheet formulas)
• Macros
• Menus
• Custom Ribbon Bars
• Real Time Data feeds

Writing a user defined function with PyXLL requires the ‘xl_func’ decorator to be applied to a normal Python function:

from pyxll import xl_func

@xl_func
def py_test(a, b, c):
    return (a + b) * c

PyXLL has a config file (pyxll.cfg) which contains a list of all the modules that will be imported when Excel starts. By adding the module above to the list in that file, PyXLL will expose the ‘py_test’ function to Excel as a user defined function to be called from a worksheet.

Some additional features of PyXLL are:

• Array functions

  PyXLL can work with arrays of data and has support for NumPy and Pandas types. Functions returning arrays can automatically resize to avoid errors when the dimensions of a result change.

• Real Time Data

  Stream real time data into Excel from Python with PyXLL’s Real Time Data feature.

• Object Cache

  For functions that return Python objects, rather than simple types (strings, numbers etc) or arrays (NumPy arrays and Pandas DataFrames or Series) PyXLL has a clever ‘object cache’. Object identifiers are returned, and when passed into another function the identifier is used to find the original object. This allows objects to be passed between Python functions using Excel formulas. This can be very useful when dealing with large data sets where the whole data set doesn’t need to be visible in Excel all at once, but instead is passed between Python functions – for example, loading a large data set and performing some aggregation operations and presenting the aggregate results in Excel.

• Excel Object Model

  PyXLL has integration with the main COM packages, pywin32 and comtypes, which allow the entire Excel Object Model to be used from Excel macros and functions written with PyXLL. This enables anything that could be done in VBA to be done in Python. It also integrates with xlwings so that the xlwings API can also be used to read and write from Excel.

For more features take a look at the feature matrix below.

Home Page | Download PyXLL | Documentation

Download PyXLL

pywin32 / comtypes

The entire Excel API (or Object Model) is exposed via COM. Everything that can be written as a VBA macro can also be written using the Excel COM API in Python by using pywin32 or comtypes.

The Excel COM API can be used from outside of Excel (e.g. from a running Python prompt, script or Jupyter notebook). If you already know how to do something in VBA then doing the equivalent task in Python via the COM API is generally quite straightforward. Calling a routine using pywin32 or comtypes from Excel (e.g. from a button on the ribbon bar, menu item or macro) can be done using PyXLL.

The Excel Object Model is documented here https://docs.microsoft.com/en-gb/office/vba/api/overview/Excel/object-model and once you understand the basic differences between VBA and Python you will find it’s fairly simple to translate between the two.

To demonstrate let’s go though an example. Suppose you had the following VBA code and want to translate it into Python:

Sub Macro1()
    Range('B11:K11').Select
    Selection.AutoFill Destination:=Range('B11:K16'), Type:=xlFillDefault
    Columns('B:K').Select
    Selection.ColumnWidth = 4
End Sub

First of all we must get the Excel Application object in Python. This code can be run from an interactive Python prompt or a Jupyter notebook, or even run inside Excel itself using PyXLL.
from win32com.client.gencache import EnsureDispatch

# Get the Excel Application COM object
xl = EnsureDispatch('Excel.Application')

Now we have the Application object we can call the Range method in the same way as the VBA code above. The first important difference to notice is that in VBA simply calling ‘Range().Select’ calls the Select method, but in Python we need to use ‘()’ to call the method.
xl.Range('B11:K11').Select()

The next line requires a constant, ‘xlFillDefault’. To access the same constant in Python we use the ‘win32com.client.constants’ module. Also notice that in VBA no parentheses are used when calling an object method, but in Python there are.
from win32com.client import constants

xl.Selection.AutoFill(Destination=xl.Range('B11:K16'), Type=constants.xlFillDefault)

The rest of the code is similar to those lines we’re just translated, and so the entire function looks like
from win32com.client.gencache import EnsureDispatch
from win32com.client import constants

def Macro1():
    xl = EnsureDispatch('Excel.Application')
    xl.Range('B11:K11').Select()
    xl.Selection.AutoFill(Destination=xl.Range('B11:K16'), Type=constants.xlFillDefault)
    xl.Columns('B:K').Select()
    xl.Selection.ColumnWidth = 4

The translated Python code looks very similar to the original VBA code! Automating tasks in Excel, or just calling it interactively in this way from a Jupyter notebook can be very powerful.
This Python code could be called from Excel as a macro using PyXLL’s “@xl_macro” decorator. Instead of using EnsureDispatch, pyxll.xl_app() should be used to ensure that if there are multiple Excel processes running the correct one is returned.

pywin32
comtypes
Python/Excel COM API Mini-cookbook

xlwings

xlwings provides a wrapper around the Excel COM API described above for simplifying many common tasks, such as writing Pandas DataFrames to an open Excel workbook. It uses pywin32’s COM wrappers and gives you access to those, so you can always drop down to using the normal Excel API should you need to.
In the same way as pywin32 and comtypes, xlwings can talk to Excel from a normal Python prompt or Jupyter notebook. For calling code using xlwings from Excel itself, PyXLL provides a convenient way of getting the Excel Application object as an xlwings object. This allows you to script Excel in Python and trigger running your code from a ribbon button or menu item. An example use-case could be a ribbon button for fetching data from a database, building a report, and writing it straight into the running Excel.
The following shows how values can be read and written to a running Excel workbook, including a Pandas DataFrame.
import xlwings as xw

wb = xw.Book('workbook.xlsx')  # Open an existing Workbook
sheet = wb.sheets['Sheet1']

# read and write values from the worksheet
sheet.range('A1').value = 'Foo'
print(sheet.range('A1').value)

# Write a Pandas DataFrames directly to the Excel sheet
import pandas as pd
df = pd.DataFrame([[1,2], [3,4]], columns=['a', 'b'])

sht.range('A1').value = df

# Read the DataFrame back, using the 'expand' option to read the whole table
sht.range('A1').options(pd.DataFrame, expand='table').value

xlwings includes a way of writing user defined functions (UDFs) or worksheet functions in Python that are called from a formula in Excel, similar to the user defined functions offered by PyXLL. These rely on a server process running outside of Excel and VBA wrappers to call into that server. It’s a simple solution with some drawbacks, such as poor performance and that those functions are only available from the workbook containing the VBA wrappers.
DataNitro

DataNitro is another API to control Excel from Python. It’s not clear what the advantage over its API and the existing and well understood Microsoft Excel COM API is, but it does allow you to write and run scripts without leaving Excel. It has rudimentary support for user defined functions (worksheet functions), but they run outside of the Excel process and only work if there is only one Excel process running.
DataNitro is no longer under active development and is not available to license any more, but it was included here for completeness.
Feature Matrix For Integrating Python and Excel





Feature
DataNitro
xlwings
PyXLL
Comments




Basic worksheet functions
✔
✔
✔
DataNitro and xlwings use an external Python process, xlwings requires VBA wrapper code


Real time data
✘
✘
✔
Stream real time data into Excel worksheets


Ribbon customisation
✘
✘
✔
Give users a rich user experience with custom ribbon menus


Custom task panes
✘
✘
✔
Integrate Python UI components into Excel


Menu functions
✘
✘
✔
Call Python code from the Excel menu


Object Cache
✘
✘
✔
Pass Python objects between worksheet functions seamlessly via an object cache


IntelliSense
✘
✘
✔
IntelliSense tooltip as you type – PyXLL integrates with the ExcelDNA Intellisense Addin


Thread safe worksheet functions
✘
✘
✔
Improve worksheet responsiveness by using Excel’s own threadpool to run worksheet functions concurrently


Asynchronous functions
✘
✘
✔
Don’t block Excel waiting for long running functions


Macros
✘
✔
✔
Macros are functions that can be attached to UI elements like buttons or called from VBA


Keyboard shortcuts
✘
✘
✔
Keyboard shortcuts can be assigned to macros with PyXLL


Macro sheet equivalent functions
✘
✘
✔
Call back into Excel from a worksheet function


Function documentation
✘
✔
✔
Include Python function docstrings in the Excel function wizard


Automatically resize arrays
✘
✔
✔
Array functions can resize automatically


Volatile Functions
✘
✔
✔
Volatile functions are called every time a worksheet is recalculated


Full Excel API exposed
✘
✔
✔
xlwings uses pywin32, PyXLL users can choose between pywin32, comtypes or xlwings


Reload without restarting Excel
✔
✔
✔
Modules can be reloaded without restarting Excel. PyXLL also supports ‘deep reloading’ where all module dependencies are also reloaded.


Automatic reloading
✘
✘
✔
Reload automatically whenever changes are made to your code.




See PyXLL’s Features
Download PyXLL
Reading and Writing Excel workbooks
For some tasks you may need to read or write an Excel file directly. For batch processing or tasks running on a server Excel may not be installed. The following packages allow you to read and write Excel files directly without needing to use Excel.

OpenPyXL

For working with Excel 2010 onwards, OpenPyXL is a great all round choice. Using OpenPyXL you can read and write xlsx, xlsm, xltx and xltm files. The following code shows how an Excel workbook can be written as an xlsx file with a few lines of Python.
from openpyxl import Workbook
wb = Workbook()

# grab the active worksheet
ws = wb.active

# Data can be assigned directly to cells
ws['A1'] = 42

# Rows can also be appended
ws.append([1, 2, 3])

# Save the file
wb.save('sample.xlsx')

Don’t confuse OpenPyXL with PyXLL. The two are completely different and serve different purposes. OpenPyXL is a package for reading and writing Excel files, whereas PyXLL is a tool for building fully featured Excel Add-Ins for integrating Python code into Excel.
OpenPyXL covers more advanced features of Excel such as charts, styles, number formatting and conditional formatting. It even includes a tokeniser for parsing Excel formulas!
One really nice feature for writing reports is its built-in support for NumPy and Pandas data. To write a Pandas DataFrame all that’s required is the included ‘dataframe_to_rows’ function:
from openpyxl.utils.dataframe import dataframe_to_rows

wb = Workbook()
ws = wb.active

for r in dataframe_to_rows(df, index=True, header=True):
ws.append(r)

wb.save('pandas_openpyxl.xlsx')

If you need to read Excel files to extract data then OpenPyXL can do that too. The Excel file types are incredibly complicated and openpyxl does an amazing job of reading them into a form that’s easy to access in Python. There are some things that openpyxl can’t load though, such as charts and images, so if you open a file and save it with the same name then some elements may be lost.
from openpyxl import load_workbook

wb = load_workbook(filename = 'book.xlsx')
sheet_ranges = wb['range names']
print(sheet_ranges['D18'].value)

A possible downside of OpenPyXL is that it can be quite slow for handling large files. If you have to write reports with thousands of rows and your application is time-sensitive then XlsxWriter or PyExcelerate may be better choices.

download openpyxl
openpyxl documentation

XlsxWriter

If you only need to write Excel workbooks and not read them then XlsxWriter is an easy to use package to use that works well. If you are working with large files or are particularly concerned about speed then you may find XlsxWriter a better choice than OpenPyXL.
XlsxWriter is a Python module that can be used to write text, numbers, formulas and hyperlinks to multiple worksheets in an Excel 2007+ XLSX file. It supports features such as formatting and many more, including:

100% compatible Excel XLSX files.
Full formatting.
Merged cells.
Defined names.
Charts.
Autofilters.
Data validation and drop down lists.
Conditional formatting.
Worksheet PNG/JPEG/BMP/WMF/EMF images.
Rich multi-format strings.
Cell comments.
Textboxes.
Integration with Pandas.
Memory optimization mode for writing large files.

Writing Excel workbooks using XlsxWriter is simple enough. Cells can be written to using the Excel address notation (eg ‘A1’) or row and column numbers. Below is a basic example that shows creating a workbook, adding some data and saving it as an xlsx file.
import xlsxwriter

workbook = xlsxwriter.Workbook('hello.xlsx')
worksheet = workbook.add_worksheet()

worksheet.write('A1', 'Hello world')

workbook.close()

If you are using Pandas then you’ll want to use XlsxWriter’s Pandas integration. It takes the hard work out of writing Pandas DataFrames to Excel, and even creating charts.
import pandas as pd

# Create a Pandas dataframe from the data.
df = pd.DataFrame({'Data': [10, 20, 30, 20, 15, 30, 45]})

# Create a Pandas Excel writer using XlsxWriter as the engine.
writer = pd.ExcelWriter('pandas_simple.xlsx', engine='xlsxwriter')

# Get the xlsxwriter objects from the dataframe writer object.
workbook  = writer.book
worksheet = writer.sheets['Sheet1']

# Create a chart object.
chart = workbook.add_chart({'type': 'column'})

# Configure the series of the chart from the dataframe data.
chart.add_series({'values': '=Sheet1!$B$2:$B$8'})

# Insert the chart into the worksheet.
worksheet.insert_chart('D2', chart)

# Convert the dataframe to an XlsxWriter Excel object.
df.to_excel(writer, sheet_name='Sheet1')

# Close the Pandas Excel writer and output the Excel file.
writer.save()

When referencing the Pandas data in the worksheet (as the formula in the chart above does), you have to figure out where the data will be in the worksheet so that the formulas point to the correct cells. For reports involving a lot of formulas or charts this can become problematic as doing something as as simple as adding an extra row requires adjusting all affected formulas. For reports like that the package ‘xltable’ can help.

download xlsxwriter
xlsxwriter documentation

XLTable

XLTable is a higher level library for building Excel reports from pandas DataFrames. Rather than writing the workbook cell by cell or row by row, whole tables are added and can include formulas that reference other tables without having to know ahead of time where those tables will be. For more complex reports involving formulas xltable can be very useful.
The main feature that makes xltable more useful than just writing the Excel files directly is that it can handle tables with formulas that relate to cells in the workbook, without having to know in advance where those tables will be placed on a worksheet. Therefore only when all the tables have been added to the workbook and the workbook is being written are formulas resolved to their final cell addresses.
If you need to write a report that includes formulas rather than just data, XLTable makes it easier by tracking the cell references so you don’t have to construct the formulas by hand and worry about references changing when tables grow or new rows or columns are added.
from xltable import *
import pandas as pd

# create a dataframe with three columns where the last is the sum of the first two
dataframe = pd.DataFrame({
        'col_1': [1, 2, 3],
        'col_2': [4, 5, 6],
        'col_3': Cell('col_1') + Cell('col_2'),
    }, columns=['col_1', 'col_2', 'col_3'])

# create the named xltable Table instance
table = Table('table', dataframe)

# create the Workbook and Worksheet objects and add table to the sheet
sheet = Worksheet('Sheet1')
sheet.add_table(table)

workbook = Workbook('example.xlsx')
workbook.add_sheet(sheet)

# write the workbook to the file using xlsxwriter
workbook.to_xlsx()

XLTable can use either XlsxWriter to write an xlsx file, or it can use pywin32 (win32com) to write directly to an open Excel application (Windows only). Writing directly to Excel is good for interactive reports. For example, you could have a button in the Excel ribbon that a user could press to query some data and produce a report. By writing it directly to Excel they can get that report immediately in Excel without having it written to a file first. For details of how to customise the Excel ribbon in Excel see PyXLL: Customizing the Ribbon.

download xltable
xltable documentation

Pandas

For working with ranges of data and reading or writing them to Excel workbooks with no frills, using pandas can be a very quick and effective method. If you don’t need much in the way of formatting and just care about getting data into or out of Excel workbooks then the pandas functions “read_excel” and “to_excel” may be just what you need.
df = pd.DataFrame([
        ('string1', 1),
        ('string2', 2),
        ('string3', 3)
     ], columns=['Name', 'Value'])

# Write dataframe to an xlsx file
df.to_excel('tmp.xlsx')

For more complex tasks because XlsxWriter, OpenPyXL and XLTable all have Pandas integration any of those can also be used to write Pandas DataFrames to Excel. But, for just getting data into Excel using Pandas directly as above is very convenient.

pandas homepage

xlrd/xlwt

xlrd and xlwt read and write the old Excel .xls files respectively. These are included in this list for completeness, but are now really only used when you are forced to deal with the legacy xls file format. They are both extremely mature packages that are very capable and stable, but xlwt will never be extended to support the newer xlsx/xlsm file formats therefore for new code dealing with modern Excel file formats they are no longer the best choice.

download xlrd
xlrd documentation
download xlwt
xlwt documentation

pyexcel

If you need to deal with multiple file formats (eg xlsx, xls, ods or csv) then pyexcel can be used to handle all of them. It wraps some of the packages above (xlrd/xlwt, openpyxl and xlxswriter and others) to give a single consistent API regardless of the file format you are working with.
The pyexcel packages focuses on data rather than formatting, so if you are looking to produce high quality reports for Excel users then you should consider the alternatives, but if you need to extract data from a spreadsheet without worrying so much about the file type then this package will help you do that.
import pyexcel as pe
records = pe.iget_records(file_name='your_file.xls')
for record in records:
    print('%s is aged at %d' % (record['Name'], record['Age']))

# Prints...
# Adam is aged at 28
# Beatrice is aged at 29
# Ceri is aged at 30
# Dean is aged at 26

pe.free_resources()


pyexcel documentation
pyexcel source code

Additional Resources


Python Jupyter Notebooks in Excel
Using Pandas In Excel 
Python as a VBA Replacement
What is the difference between PyXLL and xlwings?
Learning Python Resources