Надстройка python для 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.

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

xlwings — Make Excel fly with Python!

xlwings (Open Source)

xlwings is a BSD-licensed Python library that makes it easy to call Python from Excel and vice versa:

• Scripting: Automate/interact with Excel from Python using a syntax that is close to VBA.
• Macros: Replace your messy VBA macros with clean and powerful Python code.
• UDFs: Write User Defined Functions (UDFs) in Python (Windows only).

Numpy arrays and Pandas Series/DataFrames are fully supported. xlwings-powered workbooks are easy to distribute and work
on Windows and macOS.

xlwings includes all files in the xlwings package except the pro folder, i.e., the xlwings.pro subpackage.

xlwings PRO

xlwings PRO offers additional functionality on top of xlwings (Open Source), including:

• xlwings Server: No local Python installation required, supports Excel on the web and Google Sheets in addition to Excel on Windows and macOS. Integrates with VBA, Office Scripts and Office.js and supports custom functions on all platforms.
• xlwings Reports: the flexible, template-based reporting system
• xlwings Reader: A faster and more feature-rich alternative for pandas.read_excel() (no Excel installation required)
• Easy deployment via 1-click installer and embedded code
• See the full list of PRO features

xlwings PRO is source available and dual-licensed under one of the following licenses:

• PolyForm Noncommercial License 1.0.0 (noncommercial use is free)
• xlwings PRO License (commercial use requires a paid plan)

License Key

To use xlwings PRO, you need to install a license key on a Terminal/Command Prompt like so (alternatively, set the env var XLWINGS_LICENSE_KEY:

xlwings license update -k YOUR_LICENSE_KEY

See the docs for more details.

License key for noncommercial purpose:

• To use xlwings PRO for free in a noncommercial context, use the following license key: noncommercial.

License key for commercial purpose:

• To try xlwings PRO for free in a commercial context, request a trial license key: https://www.xlwings.org/trial
• To use xlwings PRO in a commercial context beyond the trial, you need to enroll in a paid plan (they include additional services like support and the ability to create one-click installers): https://www.xlwings.org/pricing

xlwings PRO licenses are developer licenses, are verified offline (i.e., no telemetry/license server involved) and allow royalty-free deployments to unlimited internal and external end-users and servers for a hassle-free management. Deployments use deploy keys that don’t expire but instead are bound to a specific version of xlwings.

Links

• Homepage: https://www.xlwings.org
• Quickstart: https://docs.xlwings.org/en/stable/quickstart.html
• Documentation: https://docs.xlwings.org
• Book (O’Reilly, 2021): https://www.xlwings.org/book
• Video Course: https://training.xlwings.org/p/xlwings
• Source Code: https://github.com/xlwings/xlwings

xltrail

The Excel files are also tracked with xltrail. You can see the diffs
here.

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

Обращаю внимание, что инструкция относится для версии xlwings 0.16.0 и выше. Если у вас установлена версия ниже — обновите пожалуйста пакет.

1. Установка Excel аддона 

Первое, что надо сделать — это установить специальный аддон в Excel. Для этого запустите командную строку Anaconda и введите команду:

xlwings addin install

После того, как команда отработала, то запустите Excel и вы должны увидеть новую ленту xlwings:

Далее запустите VBA редактор (Alt + F11), там в меню Tools выберите References…, в открывшемся меню активируйте xlwings:

2. Настройка ленты xlwings в Excel

Далее необходимо прописать в ленте xlwings путь до Python, а также расположение директории, куда была установлена Anaconda и как называется используемое Виртуальное окружение (environment).

Итак в поле Interpreter указываем путь до файла python.exe, включая название файла. К примеру у меня адрес следующий: D:PythonAnaconda3envsworkpython.exe

В поле Conda Base указываем адрес, куда установлена Anaconda. К примеру у меня это D:PythonAnaconda3.

Далее в поле Conda Env указываем название виртуального окружения. У меня к примеру это work. Если Вы не знаете название вашего виртуального окружения, то запустите Anaconda Navigator, далее перейдите в пункт Environments и там увидите необходимое название.

3. Запуск Python скрипта из Excel

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

3.1 Без использования VBA

Создайте Excel файл, сохраните его с любым названием, далее в этой же папке создайте python скрипт с таким же названием, как и Excel файл, в нем создайте функцию с названием main(). Эту функцию вы сможете вызвать из ленты xlwings нажав на кнопку «Run main». К примеру внесите в скрипт следующий код:

import xlwings as xw

def main():
    wb = xw.Book.caller()
    wb.sheets[0].range(‘A1’).value = ‘Hello World!’

Сохраните скрипт и запустите его, нажав на кнопку «Run main» в ленте xlwings. Если вы все сделали корректно, то в ячейке A1 Excel файла должен появиться текст «Hello World!».

3.2 С использованием VBA

Создайте Excel файл, сохраните его с любым названием

в формате с поддержкой макросов

, далее в этой же
папке создайте python скрипт с таким же названием, как и Excel файл. В скрипте создайте функцию с любым названием, к примеру:

import xlwings as xw

def hello():
    wb = xw.Book.caller()
    wb.sheets[0].range(‘A1’).value = ‘Привет мир!!!’

Далее запустите редактор VBA и в нем пропишите следующий код:

Sub HelloWorld()
    RunPython («import Excel_Xlwings; Excel_Xlwings.hello()»)
End Sub

Первая часть параметров функции (import Excel_Xlwings) указывает на название скрипта Python (Excel_Xlwings), а вторая Excel_Xlwings.hello() — на название функции в этом скрипте. Теперь выполните этот макрос, как и любой другой макрос VBA. Если сделали все правильно — то в результате в ячейке A1 Excel файла должен появиться текст «Привет мир!!!».

4. Создание пользовательских функций (UDF) в Excel при помощи Python

Как и в пункте 3.2 необходимо создать и сохранить Excel файл с поддержкой макросов, далее в той же папке, где расположен сохраненный эксель файл, создать скрипт Python и внести туда код пользовательской функции, к примеру:

import xlwings as xw

    @xw.func
def double_sum(x, y):
    «»»Возвращает сумму двух агрументов умноженную на 2″»»
    return 2 * (x + y)

Сохраняем скрипт, далее в ленте xlwings нажимаем кнопку Import Functions для загрузки созданной функции из Python в Excel. Теперь вы можете применять эту функцию, как и другие функции Excel:

Отлично. На сегодня все. Есть вопросы — задавайте в комментариях ниже.

Excel is very, very pervasive in today’s businesses. At Dataquest, we generally recommend working with code for quite a few reasons, and many of our data science courses are aimed at teaching efficient coding for data analysis and data science. But no matter how strongly you prefer working with Python, at the end of the day there is sometimes a need to present your findings or share your data using Excel.

But that doesn’t mean can’t still enjoy some of the efficiencies of Python! In fact, using a library called xlwings, you can use Python to make working in Excel faster.

In this xlwings tutorial, we’ll walk through how to use Python in Excel to execute and use some common operations like deleting rows based on certain criteria, using Excel functions and formulas, autofilling, creating sheets, charts, etc. In order to follow this post you should be familiar with basic Python concepts (objects, methods, attributes, functions) and Python’s syntax and have an intermediate knowledge of Excel and VBA.

We will be working with a data set that contains information regarding the draws of an European lottery called EuroMillions. This data set was downloaded from this link and it contains all the EuroMillions draws up to, and including, the 20th of September. The data available at that link should be updated with the latest information up to whenever you’re reading this post, but in case it’s unavailable, here’s a CSV file with the data from that link as of September 20.

Euromillions is a multinational lottery available in some European countries, specifically in Andorra, Austria, Belgium, France (including overseas regions and collectivities), Ireland, the Isle of Man, Liechtenstein, Luxembourg, Monaco, Portugal, Spain, Switzerland and the United Kingdom (source).

As of this writing, the draw consists of five numbers from a pool of 50 numbers (numbered 1 through 50) and two numbers called lucky stars from a pool of 12 numbers. In order to win the jackpot, participants must correctly choose all drawn numbers and lucky stars. The largest jackpot ever won was €190 million. (Note, though, that our data set denominates winnings in Pounds, not Euros).

In this tutorial, we’ll use Python and xlwings with Excel to clean up a data set and then generate some graphs to visualize which numbers win the EuroMillions most frequently.

import pandas as pd
import xlwings as xw
df = pd.read_csv('euromillions.csv')
df.sample(5)

The first column is the draw number, columns N1-L2 are the drawn numbers and lucky stars (by the order they were drawn), the Jackpot column is the jackpot in Euros and the Wins column tell us how many bets hit the jackpot.

Meet xlwings

xlwings is a Python library that makes some of the data analysis features of Python available in an Excel instance, including support for numpy arrays and pandas Series and DataFrames. Like any other Python library, it can be installed using common methods like pip or conda, but you can access the documentation for xlwings here if you need additional details.

Note that you’ll need to have a version of Microsoft Excel installed on the computer you’re using to do this xlwings tutorial.

xlwings objects

In xlwings there are four main object types which are, in decreasing hierarchical order: App (which represents an Excel instance), Book, Sheet and Range. In addition to these we’ll also be dealing with Chart and Shape objects. You can find useful information regarding these and other objects in the official documentation, but we’ll be looking at each of these objects one at a time.

Let’s start by creating a Book instance and naming it wb (workbook).

wb = xw.Book() # wb = xw.Book(filename) would open an existing file

When you run that code, it should look something like this.

Notice that when the code cell is run in the Jupyter Notebook, Excel is launched automatically.

By instantiating a Book object, an App object that belongs to our book object is created automatically. Here’s how we can check all opened Excel instances.

Note: we’re not going to include gifs for every step of this tutorial, because we don’t want this page to be a hassle to load for people with slow or limited internet connections. However, subsequent code-running steps should look similar to what we can see above: when we run a cell in Juypter, the Excel spreadsheet is updated in accordance with whatever code we’ve run.

print(xw.apps)

Apps([<Excel App 9536>])

The object xw.apps is an iterable. To check what workbooks belong to the unique instances in this iterable we can invoke the books method on it like so.

print(xw.apps[0].books)

Books([<Book [Book1]>])

As expected the only instance of this iterable is the workbook wb. We check this fact below.

print(xw.apps[0].books[0] == wb)

True

Similarly, we can check what sheets belong to this workbook:

print(wb.sheets)

Sheets([<Sheet [Book1]Sheet1>])

We can also refer to sheets by their name:

#creates a worksheet object assigns it to ws
ws = wb.sheets["Sheet1"]
#checks that wb.sheets[0] equals ws
print(ws == wb.sheets[0])

True

Sheet objects have a name attribute that works as expected. Let us change the name of our only sheet.

ws.name = "EuroMillions"

We can move data from certain Python objects (e.g. lists and tuples) into Excel. Let’s move the data in our dataframe into the sheet EuroMillions. To do this, we’ll make use of range to create a range object that stores the data from our DataFrame in a range of cells in Excel, starting in this case with the cell A1:

#ws.range("A1") is a Range object
ws.range("A1").value = df

Here’s how that will look:

As we can see, the index column of df was also moved to Excel. Let’s clear the contents of this sheet and copy the data without the index.

ws.clear_contents()
ws.range("A1").options(index=False).value = df

It will be useful to be able to tell where our table ends. More specifically, we’ll need the last row that has data in it. To this end, we can use the end method and the row attribute of Range objects.

The row method, not surprisingly, returns the row of the Range object.

The method end takes in as an argument a direction ("up" (or 1), "right" (or 2), "left" (or 3, "down" (or 4)) and returns another range object. It mimics the very common action in Excel CTRL+Shift+Arrow.

last_row = ws.range(1,1).end('down').row
print("The last row is {row}.".format(row=last_row))
print("The DataFrame df has {rows} rows.".format(rows=df.shape[0]))

The last row is 1142.
The DataFrame df has 1141 rows.

It checks out!

The API property

Not every Excel functionality is available as a native xlwings feature. Sometimes we’ll have to find workarounds to do what we want. Fortunately xlwings makes this very easy for us. From the Missing Features section in the official documentation:

Workaround: in essence, xlwings is just a smart wrapper around pywin32 on Windows and appscript on Mac. You can access the underlying objects by calling the api property. The underlying objects will offer you pretty much everything you can do with VBA, using the syntax of pywin32 (which pretty much feels like VBA) and appscript (which doesn’t feel like VBA). But apart from looking ugly, keep in mind that it makes your code platform specific (!). Excel Visual Basic for Applications is a rich source of explanations for the various existing Excel objects.

Sorting is one such functionality that is missing from xlwings. You may have noticed that the records are ordered from the most recent to the oldest draw. In the next few steps we’ll be reversing the order.

The object ws.range("A2:N{row}".format(row=last_row)) is a Range object. Appending the api property to it yields a VBA Range object which in turn gives access to its VBA features.

We’ll be using the Sort property of this VBA object. In its simplest application, Sort takes in two arguments: the column by which we want to order the table (as a VBA Range object), and the order type (whether we want to sort it in ascending or descending order). The second argument’s parameter’s documentation can be seen here. We’ll be sorting in ascending order.

Putting all of that together looks like this:

ws.range(
"A2:N{row}".format(row=last_row)
).api.Sort(Key1=ws.range("A:A").api, Order1=1)

True

Here’s how it’ll look on your screen after running (note that the first column has changed, and it’s now sorted in ascending rather than descending order.

Analyzing Our Data

One problem we’ll encounter in trying to analyze this data set is that the dates are scattered across three different columns. We’ll need to compress it into a single column. To do this, we’ll concatenate the columns appropriately in Excel, using Python. We begin by inserting a header in the empty adjacent column.

ws.range("O1").value = "Date"

Next, we can insert the Excel formula we want to use as a string. Note: the specifics of what argument separator you should use depends on your machine’s local regional settings. On mine, the argument separator is a comma and that’s what I’ve used in this tutorial, but on yours it might be a semicolon.

ws.range("O2").value = "=C2&D2&RIGHT(E2, 2)"

Having inserted the formula in the first cell, it’s second nature in the regular Excel workflow to autofill the rest of the cells through the end of the table. Autofill is a method of the VBA Range object. It takes as parameters the destination cells as a VBA Range object and the type of fill. We’re interested in the default one whose enumeration is 0.

ws.range("O2").api.AutoFill(
ws.range("O2:O{row}".format(row=last_row)).api,
0
)

True

Here’s roughly how the screen should look after this step; note the new «Date» column on the far right.

We can also use the named form of the type of fill we want. To do this we’ll need to retrieve it from the module xlwings.constants which contains named versions of the enumerated arguments of most VBA properties. Recall that you can always check the available attributes by printing dir(xlwings.constants).

(If you’re not familiar with it, dir is a native Python function and can take several kinds of arguments (modules, classes and regular objects (like lists and strings). For example, if you print dir(some_list) it will give you all the methods and attributes that you can use with a list.)

What we did above could also be achieved with the following code snippet.

from xlwings.constants import AutoFillType
ws.range("O2").api.AutoFill(
ws.range("O2:O{row}".format(row=last_row)).api,
    AutoFillType.xlFillDefault
)

Since we’ll be using this often, we’ll create a function that applies the default fill, given:

• a worksheet
• a string representing a cell in the worksheet
• a last row to fill.

To do this we’ll introduce a new Range method called get_address. It takes in four Boolean arguments and returns a string that identifies the range with varying levels of detail. Here’s a hopefully enlightening illustration of this method.

for arg4 in (0, 1):
for arg3 in (0,1):
for arg2 in (0,1):
for arg1 in (0,1):
print(ws.range("O2").get_address(arg1, arg2, arg3, arg4))

O2
O$2
$O2
$O$2
EuroMillions!O2
EuroMillions!O$2
EuroMillions!$O2
EuroMillions!$O$2
[Book1]EuroMillions!O2
[Book1]EuroMillions!O$2
[Book1]EuroMillions!$O2
[Book1]EuroMillions!$O$2
[Book1]EuroMillions!O2
[Book1]EuroMillions!O$2
[Book1]EuroMillions!$O2
[Book1]EuroMillions!$O$2

And now we define our function.

def autofill(worksheet, cell, last_row):
   rg_cell = worksheet.range(cell)
   to_fill = "{col}{top_row}:{col}{last_row}".format(
      col=rg_cell.get_address(0,0)[0],
      top_row=rg_cell.row,
      last_row=last_row
   )
   rg_cell.api.Autofill(worksheet.range(to_fill).api, 0)

In order to save Excel from making unnecessary computations, we’ll replace the formulas we just inserted on column O with hard coded values. Before we do this let us take a moment to think about what kind of Python object is Range.value when Range is an array.

print(type(ws.range("O2:O{row}".format(row=last_row)).value))

<class 'list'>

It’s a list! Let’s see its first ten elements.

print(ws.range('O2:O{row}'.format(row=last_row)).value[:10])

['13Feb04', '20Feb04', '27Feb04', '5Mar04', '12Mar04', '19Mar04', '26Mar04', '2Apr04', '9Apr04', '16Apr04']

If we insert this list into any range, it will place the values horizontally, which isn’t what we want. In order to place them vertically, we’ll need to use the options method of Range objects with the option transpose=True as a parameter, like this:

ws.range('O2').options(transpose=True).value
= ws.range('O2:O{row}'.format(row=last_row)).value

And we can now delete columns C through E.

ws.range('C:E').api.Delete()

True

EuroMillions format has suffered some mild modifications over the years, the last one happened on September 24, 2016.

From September 24, 2016 the amount of lucky stars changed from a pool of 11 to a pool of 12 numbers. In order to make a meaningful analysis, we’ll only consider draws that occurred after the last modification. The next code snippet finds the last game that happened prior to the modification and names it to_delete.

import datetime

for day in ws.range('L2:L{}'.format(last_row)):
# checks if day is not prior to the change of the rules
    if day.value <= datetime.datetime(2016, 9, 24, 0, 0):
        # since day is past the modification date,
        # the row we want is the previous one, hence minus 1
        to_delete = int(day.get_address(0, 0)[1:])-1
        # leave the for cycle
        break

And we can now delete every row from the first game to to_delete.

ws.range('2:{}'.format(to_delete)).api.Delete()

True

Here’s where we’re at, at this point:

Having finished preparing the data, we will now format this table. We’ll begin by setting the font of the first row to bold.

ws.range('1:1').api.Font.Bold = True

We can follow that by formatting the Jackpot column in millions. Note that the string format below depends on your machine’s local regional settings. If the format looks odd on your end, try swapping the commas with the dots. More on Excel custom formats here.

ws.range('J:J').number_format = "£##.##0,,' M'"

As an auxiliary step for what will follow, we’ll find the letter corresponding to the last column that has data.

last_column = ws.range(1,1).end('right').get_address(0,0)[0]

Let’s now add a border to the bottom of the header cells. Similarly to what we have been doing, we’ll use the api property. Additionally we are going to need the Border property of Range objects, the border orientation enumeration and the style of the border. We’ll be setting a double edged border (line style -4119) on the bottom of the header cells only (orientation 9).

ws.range('A1:{}1'.format(last_column)).api.Borders(9).LineStyle = -4119

Let us now autofit by both rows and columns.

ws.autofit()

Oops! This looks a bit squished, let us set the width of all columns to that of column J which seems to be the largest. Here is the ColumnWidth documentation that we are using just below.

ws.range('A:L').api.ColumnWidth = ws.range('J:J').api.ColumnWidth

That should look better. And we’re done with this sheet!

Let us add a new blank sheet called Frequencies and let us assign it to the Python name frequencies.

wb.sheets.add('Frequencies')
frequencies = wb.sheets['Frequencies']

We will be populating this sheet with the absolute frequencies of each number and each lucky star in the data set we just organized in the sheet EuroMillions.

# add a header for the numbers
frequencies.range('A1').value = 'Number'
# populate the fifty cells immediately below with the numbers 1 through 50
# since we're starting from the second row, we'll want to substract 1 from the row
frequencies.range('A2:A51').value = '=ROW()-1'

Below we’ll be inserting a header for the frequencies in cell B1 and in cell B2 we will input a formula that will count how many times the value in A2 occurs in the range C2:G201. In other words, we will count how many times 1 occurred in the columns N1-N5. After this we will autofill the rest of the cells on column B to do the same for their respective rows.

# add a header for the frequencies
frequencies.range('B1').value = 'Frequency'
# insert on B2 the result of a standard Excel formula
frequencies.range('B2').value = '=COUNTIF(Euromillions!$C$2:$G$201,Frequencies!A2)'
autofill(frequencies, 'B2', 51)

And we do the same for the lucky stars:

frequencies.range('D1').value = 'Lucky Star'
frequencies.range('E1').value = 'Frequency'
frequencies.range('D2:D13').value = '=ROW()-1'
frequencies.range('E2').value =
'=COUNTIF(EuroMillions!$H$2:$I$201,Frequencies!D2)'
autofill(frequencies, 'E2', 13)
frequencies.autofit()

Here’s how our new sheet should be looking at this point:

We are nearing our goal. Let’s create a sheet called Graphs.

wb.sheets.add('Graphs')
graphs = wb.sheets['Graphs']

Now we’ll create a Chart object. This will only produce a blank white box, but don’t worry! We’re going to use that box to chart our data in a moment.

nr_freq = xw.Chart()

We can name our chart similarly to what we did for sheets. The method set_source_data allows us to define the data source for our chart by passing in a range object.

nr_freq.name = 'Number Frequencies'
nr_freq.set_source_data(frequencies.range('Frequencies!B1:B51'))

Excel will try to guess what the x-axis should be, but we can force it to be the numbers we created on Frequencies by using the VBA Chart method FullSeriesCollection. We can edit the chart by using the object at index 1 of nr_freq.api:

nr_freq.api[1].FullSeriesCollection(1).XValues = '=Frequencies!A2:A51'

Excel is very good at guessing what kind of chart the user wants, but just in case it guesses incorrectly, we will force it to be a column chart. The various types of charts are listed here. Alas, the only documentation bridging these to the possible values of the chart_type attribute is the source code itself.

nr_freq.chart_type = 'column_clustered'

We will now define the height and the width of the chart. The measure unit will be points.

nr_freq.height = 250
nr_freq.width = 750

Here’s what we should be seeing at this point:

The SetElement method together with the parameter 2 sets the title above the chart. See other arguments here.

nr_freq.api[1].SetElement(2)  # Place chart title at the top
nr_freq.api[1].ChartTitle.Text = 'Number Frequencies'

And we add the final touches. We remove the legend using the HasLegend property.

nr_freq.api[1].HasLegend = 0

The xlCategory category passed in as the argument 1 to the Axes method, together with the property TickLabelSpacing set to 1, ensures that every element of our axis is displayed.

nr_freq.api[1].Axes(1).TickLabelSpacing = 1

To finish formatting this chart, we remove the outline by setting the property Visible of the Line object to 0.

graphs.shapes.api('Number Frequencies').Line.Visible = 0

And here’s what we’ll see:

Below we do nearly the same thing for the lucky stars.

ls_freq = xw.Chart()
ls_freq.top = 250
ls_freq.name = 'Lucky Star Frequencies'
ls_freq.set_source_data(frequencies.range('Frequencies!E1:E13'))
ls_freq.api[1].FullSeriesCollection(1).XValues = '=Frequencies!D2:D13'
ls_freq.chart_type = 'column_clustered'
ls_freq.height = 250
ls_freq.width = 750
ls_freq.api[1].SetElement(2)
ls_freq.api[1].ChartTitle.Text = 'Lucky Star Frequencies'
ls_freq.api[1].HasLegend = 0
ls_freq.api[1].Axes(1).TickLabelSpacing = 1
graphs.shapes.api('Lucky Star Frequencies').Line.Visible = 0

And to finalize we create a time series graph displaying the evolution of the jackpot.

jackpot = xw.Chart()
jackpot.top = 500
jackpot.name = 'Jackpot'
last_row = ws.range(1,1).end('down').row
jackpot.set_source_data(ws.range('Euromillions!J2:J{}'.format(last_row)))
jackpot.api[1].FullSeriesCollection(1).XValues
= 'Euromillions!L2:L{}'.format(last_row)
jackpot.chart_type = 'line'
jackpot.height = 250
jackpot.width = 750
jackpot.api[1].SetElement(2)
jackpot.api[1].ChartTitle.Text = 'Jackpot'
jackpot.api[1].HasLegend = 0
graphs.shapes.api('Jackpot').Line.Visible = 0

And we fix the vertical axis’ labels’ format by setting the TickLabels property NumberFormat to the desired appearance.

jackpot.api[1].Axes(2).TickLabels.NumberFormat = "£0,,' M'"

And we’re done! Now we save the file and exit our Excel instance.

wb.save('EuroMillions.xlsx')
xw.apps[0].quit()

Hopefully, this xlwings tutorial has been helpful!

Some useful resources for learning about xlwings are the official documentation, this formatting cheat sheet, the VBA for Excel documentation and the course xlwings: Python for Excel designed by Felix Zumstein himself, the developer of xlwings.

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

Параметры интеграции Excel / Python

1. Openpyxl
2. Pyxll
3. Xlrd
4. Xlwt
5. Xlutils
6. Панды
7. Pywin32
8. Xlsxwriter

1. Openpyxl

Openpyxl — это библиотека с открытым исходным кодом, поддерживающая стандарт OOXML. Стандарты OOXML для расширяемого языка разметки открытого офиса. Openpyxl можно использовать с любой версией Excel, поддерживающей этот стандарт; означает Excel 2010 (2007) по настоящее время (в настоящее время Excel 2016). Я не пробовал и не тестировал Openpyxl с Office 365. Однако альтернативное приложение для работы с электронными таблицами, такое как Office Libre Calc или Open Office Calc, которое поддерживает стандарт OOXML, также может использовать библиотеку для работы с файлами xlsx.

Openpyxl поддерживает большинство функций Excel или API-интерфейсов, включая чтение и запись в файлы, построение диаграмм, работу со сводными таблицами, синтаксический анализ формул, использование фильтров и сортировок, создание таблиц, стили и некоторые из наиболее часто используемых. Что касается обработки данных, библиотека работает как с большими, так и с маленькими наборами данных, однако вы увидите снижение производительности на очень больших наборах данных. Для работы с очень большими наборами данных вам понадобится API openpyxl.worksheet._read_only.ReadOnlyWorksheet.

openpyxl.worksheet._read_only.ReadOnlyWorksheet доступен только для чтения

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

Чтобы записать обратно свой очень большой набор данных, вы используете API openpyxl.worksheet._write_only.WriteOnlyWorksheet, чтобы выгрузить данные обратно в Excel.

Openpyxl можно установить в любой редактор поддержки Python или IDE, например Anaconda или IPython, Jupyter или любой другой, который вы используете в настоящее время. Openpyxl нельзя использовать непосредственно внутри Excel.

Примечание: для этих примеров я использую Jupyter из пакета Anaconda, который можно загрузить и установить по этому адресу: https://www.anaconda.com/distribution/, или вы можете установить только редактор Jupyter с: https: // jupyter.org /

Установка

Для установки из командной строки (команда или PowerShell в Windows или Терминал в OSX):

Пип установить openpyxl

Создать книгу

Чтобы использовать для создания книги и листа Excel:


from openpyxl import Workbook #create workbook wb = Workbook() #create excel file xl_file = 'tut_openpyxl.xlsx' #get the active worksheet (e.g. sheet1) ws1 = wb.active #add content to the sheet for row in range(1, 40): ws1.append(range(600)) #save the file wb.save(filename = xl_file)


• В приведенном выше коде мы начинаем с импорта объекта Workbook из библиотеки openpyxl.
• Затем мы определяем объект книги
• Затем мы создаем файл Excel для хранения наших данных
• Из открытой рабочей книги Excel мы получаем дескриптор активного рабочего листа (ws1)
• После этого добавьте контент, используя цикл «for».
• И наконец сохраните файл.

Два следующих снимка экрана показывают выполнение файла tut_openpyxl.py и сохранение.

Рис 1: Код

Рис2: Вывод в Excel

Чтение данных из Excel

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


from openpyxl import load_workbook #get handle on existing file wk = load_workbook(filename='countries.xlsx') #get active worksheet or wk ws = wk.active #loop through range values for t in range(1,20): range = 'A'+str(t) print(ws.value)


• Это базовый пример для чтения из файла Excel.
• Импортируйте класс load_workbook из библиотеки openpyxl
• Получите доступ к открытой книге
• Получите активный рабочий лист или именованный рабочий лист с помощью книги
• Наконец, прокрутите значения на листе

Рис 3: Считывание данных

2. Pyxll

Пакет pyxll — это коммерческое предложение, которое можно добавить или интегрировать в Excel. Немного похоже на VBA. Пакет pyxll нельзя установить, как другие стандартные пакеты Python, поскольку pyxll является надстройкой Excel. Pyxll поддерживает версии Excel с 97-2003 по настоящее время.

Установка

Инструкция по установке находится здесь:

Применение

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

3. Xlrd

Еще одна библиотека — xlrd и ее спутник xlwt ниже. Xlrd используется для чтения данных из книги Excel. Xlrd был разработан для работы со старыми версиями Excel с расширением «xls».

Установка

Установка библиотеки xlrd выполняется с помощью pip как:


pip install xlrd



Import xlrd xlrd.open_workbook(excelFilePath) sheetNames = xlWorkbook.sheet_names() xlSheet = xlWorkbook.sheet_by_name(sheetNames) # Or grab the first sheet by index xlSheet = xlWorkbook.sheet_by_index(0) # Get the first row of data row = xlSheet.row(0) #to enumerate through all columns and rows #get the number of rows in the sheet numColumns = xlSheet.ncols for rowIdx in range(0, xlSheet.nrows): # Iterate through rows print ('Row: %s' % rowIdx) # Print the row number for colIdx in range(0, numColumns): # Iterate through the columns cell = xlSheet.cell(rowIdx, colIdx) # Get cell object by row, col print ('Column: cell: ' % (colIdx, cell))


Применение

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

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

Конечно, xlrd, как следует из названия, может считывать данные только из книги Excel. Библиотека не предоставляет API для записи в файл Excel. К счастью, у xlrd есть партнер по имени xlwt, который станет следующей библиотекой, которую следует обсудить.

4. XLWT

Xlwt разработан для работы с файлами Excel версий с 95 по 2003, которые были двоичным форматом до формата OOXML (Open Office XML), представленного в Excel 2007. Библиотека xlwt работает совместно с библиотекой xlrd dscus, описанной выше.

Установка

Процесс установки прост и понятен. Как и большинство других библиотек Python, вы можете установить с помощью утилиты pip следующим образом:


pip install xlwt


Применение

Следующий фрагмент кода, адаптированный с сайта Read the Docs на xlwt, предоставляет базовые инструкции по записи данных на лист Excel, добавлению стиля и использованию формулы. За синтаксисом легко следить.


import xlwt from datetime import datetime style0 = xlwt.easyxf('font: name Times New Roman, color-index red, bold on', num_format_str='#,##0.00') style1 = xlwt.easyxf(num_format_str='D-MMM-YY') wb = xlwt.Workbook() ws = wb.add_sheet('Hello world') ws.write(0, 0, 999.99, style0) ws.write(1, 0, datetime.now(), style1) ws.write(2, 0, 1) ws.write(2, 1, 1) ws.write(2, 2, xlwt.Formula("A3+B3")) wb.save(HW.xls')


Функция записи write ( r , c , label = » , style =
), предоставляет основные возможности для записи содержимого в электронную таблицу Excel, при этом формулы являются альтернативным методом. Параметры «r» и «c» относятся к строке и столбцу соответственно.

Полная документация по использованию этого пакета Python находится здесь: https://xlwt.readthedocs.io/en/latest/. Как я уже упоминал в первом абзаце, xlwt и xlrd в этом отношении предназначены для форматов xls Excel (95-2003). Для Excel OOXML следует использовать другие библиотеки, обсуждаемые в этой статье.

5. Кслутилы

Python xlutils является продолжением xlrd и xlwt. Пакет предоставляет более обширный набор API для работы с файлами Excel на основе xls. Документацию по пакету можно найти здесь: https://pypi.org/project/xlutils/. Чтобы использовать пакет, вам также необходимо установить пакеты xlrd и xlwt.

Установка

Пакет xlutils устанавливается с помощью pip:


pip install xlutils


6. Панды

Pandas — очень мощная библиотека Python, используемая для анализа, обработки и исследования данных. Это один из столпов инженерии данных и науки о данных. Одним из основных инструментов или API в Pandas является DataFrame, представляющий собой таблицу данных в памяти. Pandas может выводить содержимое DataFrame в Excel, используя openpyxl или xlsxwriter для файлов OOXML и xlwt (см. Выше) для форматов файлов xls в качестве механизма записи. Эти пакеты необходимо установить для работы с Pandas. Вам не нужно импортировать их в свой скрипт Python, чтобы использовать их.

Установка

Чтобы установить pandas, выполните эту команду из окна интерфейса командной строки или терминала, если вы используете OSX:


pip install xlsxwriterp pip install pandas


Применение


import pandas as pd # Create a Pandas dataframe from the data. df = pd.DataFrame({'Data': }) # Create a Pandas Excel writer using XlsxWriter as the engine or openpyxl and xlwt for older versions of Excel. writer = pd.ExcelWriter('pandas xl test.xlsx', engine='xlsxwriter') # Convert the dataframe to an XlsxWriter Excel object. df.to_excel(writer, sheet_name='Test') # Close the Pandas Excel writer and output the Excel file. writer.save()


Вот снимок экрана сценария, выполнения VS Code и созданного в результате файла Excel.

Рис 4: Скрипт Pandas в VS Code

Рис 5: Вывод Pandas в Excel

7. Xlsxwriter

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

Как упоминалось ранее, он также интегрирован с Pandas, что делает его опасной комбинацией.

Полная документация находится на их сайте здесь:

Установка


pip install xlsxwriter


Применение


import xlsxwriter # create a Excel file xlWb = xlsxwriter.Workbook('simpleXl.xlsx') xlWks = xlWb.add_worksheet() # add some data groceries = (,,,,) row = 0 col = 0 # add groceries data to sheet for item, cost in (groceries): xlWks.write(row, col, item) xlWks.write(row, col + 1, cost) row += 1 # Write a total using a formula. xlWks.write(row, 0, 'Total') xlWks.write(row, 1, '=SUM(B1:B4)') xlWb.close() xlWb.close()


Следующий сценарий начинается с импорта пакета xlsxwriter из репозитория PYPI с помощью pip. Затем определите и создайте книгу и файл Excel. Затем мы определяем объект рабочего листа, xlWks, и добавляем его в рабочую книгу.

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

Следующий снимок экрана — результат в Excel.

Рис 6: XLSXWriter в Excel

8. Pywin32

Этот последний пакет Python не предназначен специально для Excel. Скорее, это оболочка Python для Windows API, которая обеспечивает доступ к COM (Common Object Model). COM — это общий интерфейс для всех приложений Windows, включая Microsoft Office, включая Excel.

Документация по пакету pywin32 находится здесь: https://github.com/mhammond/pywin32, а также здесь:

Установка


pip install pywin32


Применение

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


import win32com.client as win32 excel = win32.gencache.EnsureDispatch('Excel.Application') wb = excel.Workbooks.Add() wks = wb.Sheets.Add() wks.Name = "test" groceries = (,,,,) row=1 col=1 for item, cost in (groceries): wks.Cells(row,col).Value = item wks.Cells(row,col+1).Value = cost row += 1 wks.Cells(row, 1).Value = "Total" wks.Cells(row, 2).Value = '=SUM(B1:B4)' wb.SaveAs('C:\Users\kevin\dev\pyInExcel\simplewin32.xlsx') excel.Application.Quit()


Рис 7: Вывод Pywin32 в Excel

Заключение

Вот и все: восемь разных пакетов Python для взаимодействия с Excel.

© 2020 Кевин Лангедок