Existe-t-il un moyen d'ajuster automatiquement les largeurs de colonne Excel avec pandas.ExcelWriter?

On me demande de générer des rapports Excel. J'utilise actuellement assez massivement des pandas pour mes données, alors j'aimerais naturellement utiliser la méthode pandas.ExcelWriter pour générer ces rapports. Cependant, les largeurs de colonne fixes posent un problème.

Le code que j'ai jusqu'à présent est assez simple. Disons que j'ai un dataframe appelé 'df':

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

Je regardais le code pandas, et je ne vois vraiment aucune option pour définir la largeur des colonnes. Existe-t-il une astuce dans l'univers pour faire en sorte que les colonnes s'adaptent automatiquement aux données? Ou puis-je faire quelque chose après coup dans le fichier xlsx pour ajuster les largeurs de colonne?

(J'utilise la bibliothèque OpenPyXL et génère des fichiers .xlsx - si cela fait une différence.)

Je vous remercie.

Inspiré par la réponse de user6178746 , j'ai ce qui suit:

# 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()

Je publie ceci parce que je viens de rencontrer le même problème et que j'ai constaté que la documentation officielle de Xlsxwriter et des pandas contient toujours cette fonctionnalité répertoriée comme non prise en charge. J'ai piraté ensemble une solution qui a résolu le problème que j'avais. En gros, je parcoure chaque colonne et j'utilise worksheet.set_column pour définir la largeur de la colonne == la longueur maximale du contenu de cette colonne.

Une note importante, cependant. Cette solution ne correspond pas aux en-têtes de colonne, simplement aux valeurs de colonne. Cela devrait être un changement facile si vous avez besoin d'ajuster les en-têtes à la place. J'espère que cela aide quelqu'un :)

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()

Il n'y a probablement pas de moyen automatique de le faire pour le moment, mais comme vous utilisez openpyxl, la ligne suivante (adaptée d'une autre réponse de l'utilisateur Bufke sur la façon de faire manuellement ) vous permet de spécifier une valeur saine (en largeurs de caractères):

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

Il y a un joli package que j'ai commencé à utiliser récemment appelé StyleFrame.

il obtient DataFrame et vous permet de le styliser très facilement ...

par défaut, la largeur des colonnes s'ajuste automatiquement.

par exemple:

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()

vous pouvez également modifier la largeur des colonnes:

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

METTRE À JOUR

Dans la version 1.4, l' best_fitargument a été ajouté à StyleFrame.to_excel. Consultez la documentation .

En utilisant pandas et xlsxwriter, vous pouvez faire votre tâche, le code ci-dessous fonctionnera parfaitement dans Python 3.x. Pour plus de détails sur l'utilisation de XlsxWriter avec les pandas, ce lien peut être utile 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()

J'ai trouvé qu'il était plus utile d'ajuster la colonne en fonction de l'en-tête de colonne plutôt que du contenu de la colonne.

En utilisant df.columns.values.tolist()je génère une liste des en-têtes de colonne et utilise les longueurs de ces en-têtes pour déterminer la largeur des colonnes.

Voir le code complet ci-dessous:

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

Au travail, j'écris toujours les dataframes dans des fichiers Excel. Donc, au lieu d'écrire le même code encore et encore, j'ai créé un module. Maintenant, je viens de l'importer et de l'utiliser pour écrire et formater les fichiers Excel. Il y a cependant un inconvénient, cela prend beaucoup de temps si la trame de données est très grande. Voici donc le code:

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

Ajuster dynamiquement toutes les longueurs de colonne

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)

Ajuster manuellement une colonne à l'aide du nom de la colonne

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

Ajuster manuellement une colonne à l'aide de l'index de colonne

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

Au cas où l'un des éléments ci-dessus échouerait avec

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

assurez-vous d'installer xlsxwriter:

pip install xlsxwriter

Combinaison des autres réponses et commentaires et prise en charge des multi-indices:

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

La solution la plus simple consiste à spécifier la largeur de la colonne dans la méthode 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)