top of page

Automate Microsoft Excel and Word Using Python

Updated: Feb 14

By automating Excel and word tasks, you can save time, reduce errors, and increase productivity. This can involve reading and writing data to and from Excel spreadsheets, manipulating data within Excel, and automating various Excel functions and processes. Some of the common tasks that can be automated in Excel using Python include data analysis, filtering, sorting, formatting, charting, and generating reports. There are several Python libraries that can be used to automate Excel tasks, including openpyxl, pandas, and win32com.


openpyxl is a Python library that allows for working with Excel files. It can be used to read, write and modify Excel files (both .xlsx and .xlsm) programmatically. The library allows you to interact with individual cells, rows, columns, worksheets, and entire workbooks.

Some of the features of openpyxl include:

  • Reading and writing data to and from cells

  • Merging cells

  • Creating and deleting rows and columns

  • Creating and deleting worksheets

  • Formatting cells (font, fill, borders, etc.)

  • Adding charts and images

  • Creating and working with named ranges

  • Creating and working with data validation rules


pandas is a popular Python library for data manipulation and analysis. It provides data structures and functions for efficiently handling and analyzing large amounts of data in a flexible and easy-to-use way.

Some of the features of pandas include:

  • Reading and writing data to and from various file formats, including Excel files

  • Data manipulation and cleaning, including filtering, sorting, joining, grouping, and reshaping data

  • Handling missing data and data imputation

  • Time series analysis and manipulation

  • Statistical analysis and computation, including descriptive statistics, regression, and correlation analysis

  • Visualization of data using built-in plotting functions


win32com is a Python library that allows you to automate Microsoft Office applications, including Excel, Word, PowerPoint, and Outlook, using the Windows COM interface. With win32com, you can automate a wide range of Office tasks, including opening and closing files, manipulating data, formatting text and cells, creating charts and graphs, and sending emails. It provides full access to the Office object model, allowing you to perform any action that can be done manually in the Office applications.

Automating Microsoft Excel with Python:

a. Reading and writing data in Excel:

You can use Python's openpyxl library to read and write data in Excel spreadsheets. It allows you to create, read, write, and modify Excel files.

import openpyxl

# Open workbook
workbook = openpyxl.load_workbook('example.xlsx')

# Select sheet
sheet = workbook['Sheet1']

# Read data from a cell
cell_value = sheet['A1'].value

# Write data to a cell
sheet['B1'] = 'Hello, world!'# Save changes'example.xlsx')

b. Manipulating data in Excel:

Python's pandas library provides functionality for data manipulation in Excel. You can use it to perform data analysis, filtering, sorting, and other operations on large datasets.

import pandas as pd

# Read data from Excel into a dataframedf = pd.read_excel('example.xlsx', sheet_name='Sheet1')

# Filter datadf = df[df['Column1'] > 10]

# Sort datadf = df.sort_values('Column2')

# Write data back to Excel
with pd.ExcelWriter('example.xlsx') as writer:
    df.to_excel(writer, sheet_name='Sheet1')

c. Automating Excel tasks:

Python's win32com library allows you to automate Excel tasks such as opening, saving, and closing workbooks, copying and pasting data, and formatting cells.

import win32com.client

# Open Excel
excel = win32com.client.Dispatch('Excel.Application')
excel.Visible = True# Open workbook
workbook = excel.Workbooks.Open('example.xlsx')

# Copy data

# Paste data

# Save and close workbook


Here's an example of how to automate Microsoft Excel using Python with the openpyxl library to read data from an Excel file, manipulate it, and write the updated data back to a new Excel file:

import openpyxl

# Open the workbook and select the worksheet
workbook = openpyxl.load_workbook('example.xlsx')
worksheet = workbook['Sheet1']

# Iterate through each row in the worksheet and update the data for row in worksheet.iter_rows(min_row=2, values_only=True):
    if row[2] > 50:
        row[3] = row[1] * 0.1# Save the updated data to a new Excel file'updated_data.xlsx')

In this example, we load the data from an Excel file named example.xlsx and select the Sheet1 worksheet. We then iterate through each row of the worksheet (starting with the second row) and check if the value in the third column is greater than 50. If it is, we update the value in the fourth column to be 10% of the value in the second column.

Finally, we save the updated data to a new Excel file named updated_data.xlsx. Here is what the updated Excel file might look like:

As you can see, the values in the fourth column have been updated for the rows where the value in the third column was greater than 50.

Automating Microsoft Word with Python:

a. Reading and writing data in Word:

Python's python-docx library allows you to read and write data in Word documents. You can use it to create, read, write, and modify Word files.

from docx import Document

# Open document
document = Document('example.docx')

# Read data from a paragraph
paragraph = document.paragraphs[0]
text = paragraph.text

# Write data to a paragraph
paragraph.text = 'Hello, world!'# Save changes'example.docx')

b. Manipulating data in Word:

Python's docx2python library provides functionality for data manipulation in Word. You can use it to extract text, tables, images, and other data from Word documents.

from docx2python import docx2python

# Read data from Word into a dictionary
doc = docx2python('example.docx')
table = doc.tables[0]
data = [row[0] for row in table[1:]]

# Modify data
data = [x.upper() for x in data]

# Write data back to Word
for i, row in enumerate(table[1:]):
    row[0] = data[i]

# Save changes

c. Automating Word tasks:

Python's win32com library allows you to automate Word tasks such as opening, saving, and closing documents, adding and formatting text, and creating tables and charts.

import win32com.client

# Open Word
word = win32com.client.Dispatch('Word.Application')
word.Visible = True

# Open document
document = word.Documents.Open('example.docx')

# Add text to document
paragraph = document.Content.Paragraphs.Add()
paragraph.Range.Text = 'Hello, world!'

# Save and close document

By combining different libraries and techniques, you can create complex scripts that manipulate data, perform calculations, and generate reports, all with just a few lines of code.


Here's an example of how to automate Microsoft Word using Python with the win32com library to create a new Word document, add some text and formatting, and save it:

import win32com.client as win32

# Create a new Word document
word = win32.gencache.EnsureDispatch('Word.Application')
doc = word.Documents.Add()

# Add some text to the document
doc.Range().Text = 'Hello, world!'# Apply some formatting to the text
doc.Range().Font.Name = 'Calibri'
doc.Range().Font.Size = 16
doc.Range().Font.Bold = True
doc.Range().ParagraphFormat.Alignment = win32.constants.wdAlignParagraphCenter

# Save the document

# Close the Word application

In this example, we use the win32com library to create a new instance of the Word application, and then use the Documents.Add() method to create a new, blank Word document.

Next, we use the doc.Range().Text property to add some text to the document, and then use the doc.Range().Font and doc.Range().ParagraphFormat properties to apply some formatting to the text. In this case, we set the font to Calibri, the size to 16, and the alignment to centered.

Finally, we use the doc.SaveAs() method to save the document to a file named hello_world.docx, and the word.Quit() method to close the Word application.

Here's what the resulting Word document might look like:

Hello, world!

The text is centered, bolded, and formatted in Calibri with a font size of 16.

Benefits and Limitations of Automate Excel and word using Python

Automating Microsoft Excel and Word using Python can offer several advantages, but it also has some potential drawbacks. Here are some pros and cons of automating these applications with Python:


  • Increased efficiency: Automating Excel and Word tasks can help to save time, reduce errors, and improve productivity.

  • Improved accuracy: Automating tasks can help to ensure consistent and accurate results, reducing the likelihood of errors or mistakes.

  • Increased scalability: Automating tasks allows for the processing of larger data sets, and can help to increase the capacity of Excel and Word functions and features.

  • Greater flexibility: Python provides a more flexible and powerful programming environment than Excel macros or VBA, allowing for more complex and sophisticated automation tasks.


  • Learning curve: Python programming requires learning a new language, which may take time and effort to master.

  • Compatibility issues: Some Excel and Word features and functions may not be available or compatible with Python libraries or packages.

  • Maintenance: Automation code needs to be updated and maintained over time to ensure continued compatibility with changes to Excel and Word features and functions.

  • Performance: In some cases, automating tasks with Python may be slower than using Excel or Word functions directly, depending on the size and complexity of the data being processed.


Recent Posts

See All
bottom of page