Existe uma maneira de ajustar automaticamente as larguras das colunas do Excel com o pandas.ExcelWriter?

Estou sendo solicitado a gerar alguns relatórios do Excel. No momento, estou usando bastante o pandas para meus dados, então, naturalmente, gostaria de usar o método pandas.ExcelWriter para gerar esses relatórios. No entanto, as larguras fixas das colunas são um problema.

O código que tenho até agora é bastante simples. Digamos que eu tenha um dataframe chamado 'df':

writer = pd.ExcelWriter(excel_file_path, engine='openpyxl')
df.to_excel(writer, sheet_name="Summary")

Eu estava examinando o código do pandas e não vejo nenhuma opção para definir as larguras das colunas. Existe algum truque no universo para fazer com que as colunas se ajustem automaticamente aos dados? Ou há algo que posso fazer após o fato no arquivo xlsx para ajustar as larguras das colunas?

(Estou usando a biblioteca OpenPyXL e gerando arquivos .xlsx - se isso fizer alguma diferença.)

Obrigado.

Inspirado pela resposta do usuário6178746 , tenho o seguinte:

# Given a dict of dataframes, for example:
# dfs = {'gadgets': df_gadgets, 'widgets': df_widgets}

writer = pd.ExcelWriter(filename, engine='xlsxwriter')
for sheetname, df in dfs.items():  # loop through `dict` of dataframes
    df.to_excel(writer, sheet_name=sheetname)  # send df to writer
    worksheet = writer.sheets[sheetname]  # pull worksheet object
    for idx, col in enumerate(df):  # loop through all columns
        series = df[col]
        max_len = max((
            series.astype(str).map(len).max(),  # len of largest item
            len(str(series.name))  # len of column name/header
            )) + 1  # adding a little extra space
        worksheet.set_column(idx, idx, max_len)  # set column width
writer.save()

Estou postando isso porque acabei de ter o mesmo problema e descobri que a documentação oficial do Xlsxwriter e do pandas ainda tem essa funcionalidade listada como sem suporte. Eu criei uma solução que resolveu o problema que eu estava tendo. Basicamente, eu apenas itero por cada coluna e uso worksheet.set_column para definir a largura da coluna == o comprimento máximo do conteúdo dessa coluna.

Uma nota importante, entretanto. Esta solução não cabe nos cabeçalhos das colunas, apenas nos valores das colunas. Essa deve ser uma mudança fácil se você precisar ajustar os cabeçalhos. Espero que isso ajude alguém :)

import pandas as pd
import sqlalchemy as sa
import urllib


read_server = 'serverName'
read_database = 'databaseName'

read_params = urllib.quote_plus("DRIVER={SQL Server};SERVER="+read_server+";DATABASE="+read_database+";TRUSTED_CONNECTION=Yes")
read_engine = sa.create_engine("mssql+pyodbc:///?odbc_connect=%s" % read_params)

#Output some SQL Server data into a dataframe
my_sql_query = """ SELECT * FROM dbo.my_table """
my_dataframe = pd.read_sql_query(my_sql_query,con=read_engine)

#Set destination directory to save excel.
xlsFilepath = r'H:\my_project' + "\\" + 'my_file_name.xlsx'
writer = pd.ExcelWriter(xlsFilepath, engine='xlsxwriter')

#Write excel to file using pandas to_excel
my_dataframe.to_excel(writer, startrow = 1, sheet_name='Sheet1', index=False)

#Indicate workbook and worksheet for formatting
workbook = writer.book
worksheet = writer.sheets['Sheet1']

#Iterate through each column and set the width == the max length in that column. A padding length of 2 is also added.
for i, col in enumerate(my_dataframe.columns):
    # find length of column i
    column_len = my_dataframe[col].astype(str).str.len().max()
    # Setting the length if the column header is larger
    # than the max column value length
    column_len = max(column_len, len(col)) + 2
    # set the column length
    worksheet.set_column(i, i, column_len)
writer.save()

Provavelmente não há uma maneira automática de fazer isso agora, mas como você usa openpyxl, a seguinte linha (adaptada de outra resposta do usuário Bufke sobre como fazer manualmente ) permite que você especifique um valor lógico (em larguras de caracteres):

writer.sheets['Summary'].column_dimensions['A'].width = 15

Há um bom pacote que comecei a usar recentemente chamado StyleFrame.

obtém DataFrame e permite estilizá-lo com muita facilidade ...

por padrão, a largura das colunas é ajustada automaticamente.

por exemplo:

from StyleFrame import StyleFrame
import pandas as pd

df = pd.DataFrame({'aaaaaaaaaaa': [1, 2, 3], 
                   'bbbbbbbbb': [1, 1, 1],
                   'ccccccccccc': [2, 3, 4]})
excel_writer = StyleFrame.ExcelWriter('example.xlsx')
sf = StyleFrame(df)
sf.to_excel(excel_writer=excel_writer, row_to_add_filters=0,
            columns_and_rows_to_freeze='B2')
excel_writer.save()

você também pode alterar a largura das colunas:

sf.set_column_width(columns=['aaaaaaaaaaa', 'bbbbbbbbb'],
                    width=35.3)

ATUALIZAR

Na versão 1.4, o best_fitargumento foi adicionado StyleFrame.to_excel. Veja a documentação .

Usando pandas e xlsxwriter você pode fazer sua tarefa, o código abaixo funcionará perfeitamente em Python 3.x. Para obter mais detalhes sobre como trabalhar com XlsxWriter com pandas, este link pode ser útil https://xlsxwriter.readthedocs.io/working_with_pandas.html

import pandas as pd
writer = pd.ExcelWriter(excel_file_path, engine='xlsxwriter')
df.to_excel(writer, sheet_name="Summary")
workbook = writer.book
worksheet = writer.sheets["Summary"]
#set the column width as per your requirement
worksheet.set_column('A:A', 25)
writer.save()

Descobri que era mais útil ajustar a coluna com base no cabeçalho da coluna do que no conteúdo da coluna.

Usando, df.columns.values.tolist()eu gero uma lista dos cabeçalhos das colunas e uso os comprimentos desses cabeçalhos para determinar a largura das colunas.

Veja o código completo abaixo:

import pandas as pd
import xlsxwriter

writer = pd.ExcelWriter(filename, engine='xlsxwriter')
df.to_excel(writer, index=False, sheet_name=sheetname)

workbook = writer.book # Access the workbook
worksheet= writer.sheets[sheetname] # Access the Worksheet

header_list = df.columns.values.tolist() # Generate list of headers
for i in range(0, len(header_list)):
    worksheet.set_column(i, i, len(header_list[i])) # Set column widths based on len(header)

writer.save() # Save the excel file

No trabalho, estou sempre gravando os dataframes em arquivos do Excel. Portanto, em vez de escrever o mesmo código repetidamente, criei um módulo. Agora, acabei de importá-lo e usá-lo para escrever e formatar os arquivos do Excel. Há uma desvantagem, porém, leva muito tempo se o dataframe for muito grande. Então, aqui está o código:

def result_to_excel(output_name, dataframes_list, sheet_names_list, output_dir):
    out_path = os.path.join(output_dir, output_name)
    writerReport = pd.ExcelWriter(out_path, engine='xlsxwriter',
                    datetime_format='yyyymmdd', date_format='yyyymmdd')
    workbook = writerReport.book
    # loop through the list of dataframes to save every dataframe into a new sheet in the excel file
    for i, dataframe in enumerate(dataframes_list):
        sheet_name = sheet_names_list[i]  # choose the sheet name from sheet_names_list
        dataframe.to_excel(writerReport, sheet_name=sheet_name, index=False, startrow=0)
        # Add a header format.
        format = workbook.add_format({
            'bold': True,
            'border': 1,
            'fg_color': '#0000FF',
            'font_color': 'white'})
        # Write the column headers with the defined format.
        worksheet = writerReport.sheets[sheet_name]
        for col_num, col_name in enumerate(dataframe.columns.values):
            worksheet.write(0, col_num, col_name, format)
        worksheet.autofilter(0, 0, 0, len(dataframe.columns) - 1)
        worksheet.freeze_panes(1, 0)
        # loop through the columns in the dataframe to get the width of the column
        for j, col in enumerate(dataframe.columns):
            max_width = max([len(str(s)) for s in dataframe[col].values] + [len(col) + 2])
            # define a max width to not get to wide column
            if max_width > 50:
                max_width = 50
            worksheet.set_column(j, j, max_width)
    writerReport.save()
    writerReport.close()
    return output_dir + output_name

Ajuste dinamicamente todos os comprimentos das colunas

writer = pd.ExcelWriter('/path/to/output/file.xlsx') 
df.to_excel(writer, sheet_name='sheetName', index=False, na_rep='NaN')

for column in df:
    column_length = max(df[column].astype(str).map(len).max(), len(column))
    col_idx = df.columns.get_loc(column)
    writer.sheets['sheetName'].set_column(col_idx, col_idx, column_length)

Ajuste manualmente uma coluna usando o nome da coluna

col_idx = df.columns.get_loc('columnName')
writer.sheets['sheetName'].set_column(col_idx, col_idx, 15)

Ajuste manualmente uma coluna usando o Índice de coluna

writer.sheets['sheetName'].set_column(col_idx, col_idx, 15)

Caso alguma das opções acima esteja falhando com

AttributeError: 'Worksheet' object has no attribute 'set_column'

certifique-se de instalar xlsxwriter:

pip install xlsxwriter

Combinando as outras respostas e comentários e também suportando vários índices:

def autosize_excel_columns(worksheet, df):
  autosize_excel_columns_df(worksheet, df.index.to_frame())
  autosize_excel_columns_df(worksheet, df, offset=df.index.nlevels)

def autosize_excel_columns_df(worksheet, df, offset=0):
  for idx, col in enumerate(df):
    series = df[col]
    max_len = max((
      series.astype(str).map(len).max(),
      len(str(series.name))
    )) + 1
    worksheet.set_column(idx+offset, idx+offset, max_len)

sheetname=...
df.to_excel(writer, sheet_name=sheetname, freeze_panes=(df.columns.nlevels, df.index.nlevels))
worksheet = writer.sheets[sheetname]
autosize_excel_columns(worksheet, df)
writer.save()

import re
import openpyxl
..
for col in _ws.columns:
    max_lenght = 0
    print(col[0])
    col_name = re.findall('\w\d', str(col[0]))
    col_name = col_name[0]
    col_name = re.findall('\w', str(col_name))[0]
    print(col_name)
    for cell in col:
        try:
            if len(str(cell.value)) > max_lenght:
                max_lenght = len(cell.value)
        except:
            pass
    adjusted_width = (max_lenght+2)
    _ws.column_dimensions[col_name].width = adjusted_width

A solução mais fácil é especificar a largura da coluna no método set_column.

    for worksheet in writer.sheets.values():
        worksheet.set_column(0,last_column_value, required_width_constant)

def auto_width_columns(df, sheetname):
    workbook = writer.book  
    worksheet= writer.sheets[sheetname] 

    for i, col in enumerate(df.columns):
        column_len = max(df[col].astype(str).str.len().max(), len(col) + 2)
        worksheet.set_column(i, i, column_len)