Python windows com object - Windowsa.top - ваш верный помощник с OS Windows

Введение

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

Источник

Existing document

\com\win32com\html\QuickStartClientCom.html

Introduction¶

This documents how to quickly start using COM from Python. It is not a thorough discussion of the COM system, or of the concepts introduced by COM.

Other good information on COM can be found in various conference tutorials. Please see the collection of Mark’s conference tutorials 💀🔗.

For information on implementing COM objects using Python, please see a Quick Start to Server side COM and Python.

Quick Start¶

To use a COM object from Python¶

import win32com.client
o = win32com.client.Dispatch("Object.Name")
o.Method()
o.property = "New Value"
print o.property

Example:

o = win32com.client.Dispatch("Excel.Application")
o.Visible = 1
o.Workbooks.Add() # for office 97 – 95 a bit different!
o.Cells(1,1).Value = "Hello"

And we will see the word “Hello” appear in the top cell.

How do I know which methods and properties are available?¶

Good question. This is hard! You need to use the documentation with the products, or possibly a COM browser. Note however that COM browsers typically rely on these objects registering themselves in certain ways, and many objects to not do this. You are just expected to know.

The Python COM browser¶

PythonCOM comes with a basic COM browser that may show you the information you need. Note that this package requires Pythonwin (i.e., the MFC GUI environment) to be installed for this to work.

There are far better COM browsers available. I tend to use the one that comes with MSVC, or this one!

To run the browser, simply select it from the Pythonwin menu, or double-click on the file win32comclientcombrowse.py

Static Dispatch (or Type Safe) objects¶

In the above examples, if we printed the repr(o) object above, it would have resulted in:

<COMObject Excel.Application>

This reflects that the object is a generic COM object that Python has no special knowledge of (other than the name you used to create it!). This is known as a dynamic dispatch object, as all knowledge is built dynamically. The win32com package also has the concept of static dispatch objects, which gives Python up-front knowledge about the objects that it is working with (including arguments, argument types, etc.).

In a nutshell, Static Dispatch involves the generation of a .py file that contains support for the specific object. For more overview information, please see the documentation references above.

The generation and management of the .py files is somewhat automatic, and involves one of two steps:

Using makepy.py to select a COM library. This process is very similar to Visual Basic, where you select from a list of all objects installed on your system, and once selected the objects are magically useable.

Use explicit code to check for, and possibly generate, support at run-time. This is very powerful, as it allows the developer to avoid ensuring the user has selected the appropriate type library. This option is extremely powerful for OCX users, as it allows Python code to sub-class an OCX control, but the actual sub-class can be generated at run-time. Use makepy.py with a -i option to see how to include this support in your Python code.

Todo

Add an option directive for and option role to the -i command line option above.

The win32com.client.gencache module manages these generated files. This module has some documentation of its own, but you probably don’t need to know the gory details!

How do I get at the generated module?¶

You will notice that the generated file name is long and cryptic — obviously not designed for humans to work with! So how do you get at the module object for the generated code?

Hopefully, the answer is you shouldn’t need to. All generated file support is generally available directly via win32com.client.Dispatch and win32com.client.constants. But should you ever really need the Python module object, the win32com.client.gencache module has functions specifically for this. The functions GetModuleForCLSID and GetModuleForProgID both return Python module objects that you can use in your code. See the docstrings in the gencache code for more details.

To generate Python Sources supporting a COM object¶

Example using Microsoft Office 97¶

Either:

Run win32comclientmakepy.py (e.g., run it from the command window, or double-click on it) and a list will be presented. Select the Type Library ‘Microsoft Word 8.0 Object Library’
From a command prompt, run the command makepy.py «Microsoft Word 8.0 Object Library» (include the double quotes). This simply avoids the selection process.
If you desire, you can also use explicit code to generate it just before you need to use it at runtime. Run makepy.py -i «Microsoft Word 8.0 Object Library» (include the double quotes) to see how to do this.

And that is it! Nothing more needed. No special import statements needed! Now, you simply need say:

>>> import win32com.client
>>> w=win32com.client.Dispatch("Word.Application")
>>> w.Visible=1
>>> w
<win32com.gen_py.Microsoft Word 8.0 Object Library._Application>

Note that now Python knows the explicit type of the object.

Using COM Constants¶

Makepy automatically installs all generated constants from a type library in an object called win32com.clients.constants. You do not need to do anything special to make these constants work, other than create the object itself (i.e., in the example above, the constants relating to Word would automatically be available after the w=win32com.client.Dispatch("Word.Application") statement).

For example, immediately after executing the code above, you could execute the following:

>>> w.WindowState = win32com.client.constants.wdWindowStateMinimize

and Word will Minimize.

Источник

Запускаем в PythonWin — > Tools — > COM Browser — >

смотрим название интересующей нас библиотеки в «Registered Type Libraries» — >

запускаем python.exe — >

&gt;&gt;&gt; import win32com.client.makepy as makepy<br/>
&gt;&gt;&gt; makepy.ShowInfo('название интересующей нас библиотеки, которое мы нашли в Registered Type Libraries')

— > ура! он нам сгенерит модуль, который поместит в специальную папку <module ‘win32com.gen_py.название-модуля-из-большого-количества-букв-и-цифр’ from ‘C:\Python26\lib\site-packages\win32com\gen_py\название-модуля-из-большого-количества-букв-и-цифр’>

И этот модуль, с большущим, неимпортируемым названием, реально появится в той папке — …/gen_py

А вопрос вот в чем. Что с этим модулем можно сделать дальше? И, соответственно — как?

С помощью win32com.client.Dispatch(‘название-чего-то’) мы можем обращаться к интерфейсам, которые указаны в спецификациях. И делать с ними то, что там указано.

Однако, если мы не знаем «названия-этого-чего-то» — как найти и использовать то, что нам позволяет делать запущенный и действующий сервер COM-объектов?

Интересует конкретно — как обратиться к интерфейсам?

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

Источник

Using COM Objects from Python

When people
discuss COM, they are often talking about only one side of
COM—using automation objects. Automation objects are objects
that expose a programmable interface that can be used by another
program or environment. Examples of automation objects are Microsoft
Office, the Netscape browser, or programs you write yourself in any
language, such as Visual Basic, Python, Delphi, C++, and so forth.

Information about COM objects is stored in the Windows
registry. Details about the
object’s class are stored, so that when that particular object
needs to be created, the correct class is located and used. Although
the term
“class”
doesn’t refer to a Python (or C++) class, the concept is
identical: the class defines the implementation, and the object is an
instance of the class. Classes are registered with a unique (but
complex)
class ID (CLSID) and a
friendly (but not guaranteed unique) program ID (ProgID). The CLSID is a

globally
unique identifier (GUID), as discussed later in this chapter, while
the ProgID for an object is a short string that names the object and
typically creates an instance of the object. For example, Microsoft
Excel defines its ProgID as Excel.Application,
Microsoft Word defines Word.Application, and so
forth.

Python programs use the
win32com.client.Dispatch()
method to create COM objects from a
ProgID or CLSID. For example, you could use this code to create an
Excel object:

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

Источник

Python · October 25, 2024

Python is a versatile programming language that has gained immense popularity due to its simplicity and wide range of applications. One of the powerful libraries available in Python is win32com, which allows for automation and interaction with Windows COM (Component Object Model) objects. This article will delve into the win32com library, its functionalities, and how to use it effectively in your Python projects.

COM is a Microsoft technology that allows different software components to communicate with each other. It is widely used in Windows applications to enable inter-process communication. The win32com library is part of the PyWin32 package, which provides access to many of the Windows APIs from Python. This library allows Python scripts to interact with COM objects, enabling automation of tasks in applications like Microsoft Office, Internet Explorer, and more.

To use the win32com library, you first need to install the PyWin32 package. This can be done easily using pip. Open your command prompt and run the following command:

pip install pywin32

Once installed, you can start using the win32com library in your Python scripts.

The win32com library allows you to create and manipulate COM objects. Here’s a simple example of how to use it to automate Microsoft Excel:

Example: Automating Excel

import win32com.client

# Create an instance of Excel
excel = win32com.client.Dispatch('Excel.Application')

# Make Excel visible
excel.Visible = True

# Add a new workbook
workbook = excel.Workbooks.Add()

# Access the first sheet
sheet = workbook.Sheets(1)

# Write data to the sheet
sheet.Cells(1, 1).Value = 'Hello, World!'
sheet.Cells(2, 1).Value = 'This is a test.'

# Save the workbook
workbook.SaveAs('C:\path\to\your\file.xlsx')

# Close Excel
excel.Quit()

In this example, we create an instance of Excel, make it visible, add a new workbook, write some data to the first sheet, save the workbook, and finally close Excel. This demonstrates how win32com can be used to automate tasks in desktop applications.

Automating Office Applications: You can automate tasks in Microsoft Word, Excel, and PowerPoint, such as generating reports, creating presentations, and manipulating documents.
Web Automation: The library can be used to control Internet Explorer for web scraping or automated testing.
File Management: Automate file operations like copying, moving, or renaming files using Windows Explorer.

Handling Errors

When working with COM objects, it is essential to handle errors gracefully. You can use try-except blocks to catch exceptions that may arise during automation. Here’s an example:

try:
    # Your COM automation code here
except Exception as e:
    print(f'An error occurred: {e}')

Conclusion

The win32com library is a powerful tool for automating tasks in Windows applications using Python. Its ability to interact with COM objects opens up a wide range of possibilities for developers looking to streamline their workflows. Whether you are automating Excel reports or controlling web browsers, win32com provides the functionality needed to enhance productivity.

For those interested in deploying Python applications or automating tasks on a server, consider utilizing a reliable VPS solution. With USA VPS Hosting, you can ensure that your applications run smoothly and efficiently.

Источник