Gibt es eine Möglichkeit, die Breite von Excel-Spalten mit pandas.ExcelWriter automatisch anzupassen?

Ich werde gebeten, einige Excel-Berichte zu erstellen. Ich verwende derzeit ziemlich häufig Pandas für meine Daten, daher möchte ich natürlich die pandas.ExcelWriter-Methode verwenden, um diese Berichte zu generieren. Die festen Spaltenbreiten sind jedoch ein Problem.

Der Code, den ich bisher habe, ist einfach genug. Angenommen, ich habe einen Datenrahmen mit dem Namen 'df':

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

Ich habe den Pandas-Code durchgesehen und sehe keine Optionen zum Festlegen der Spaltenbreite. Gibt es da draußen im Universum einen Trick, um die Spalten automatisch an die Daten anzupassen? Oder kann ich nachträglich etwas an der xlsx-Datei tun, um die Spaltenbreiten anzupassen?

(Ich verwende die OpenPyXL-Bibliothek und generiere XLSX-Dateien - wenn das einen Unterschied macht.)

Danke dir.

Inspiriert von der Antwort von user6178746 habe ich Folgendes:

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

Ich poste dies, weil ich gerade auf dasselbe Problem gestoßen bin und festgestellt habe, dass in der offiziellen Dokumentation für Xlsxwriter und Pandas diese Funktionalität weiterhin als nicht unterstützt aufgeführt ist. Ich habe eine Lösung gehackt, die das Problem gelöst hat, das ich hatte. Ich iteriere einfach durch jede Spalte und benutze worksheet.set_column, um die Spaltenbreite == die maximale Länge des Inhalts dieser Spalte festzulegen.

Ein wichtiger Hinweis jedoch. Diese Lösung passt nicht zu den Spaltenüberschriften, sondern nur zu den Spaltenwerten. Dies sollte jedoch eine einfache Änderung sein, wenn Sie stattdessen die Header anpassen müssen. Hoffe das hilft jemandem :)

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

Derzeit gibt es wahrscheinlich keine automatische Möglichkeit, dies zu tun. Wenn Sie jedoch openpyxl verwenden, können Sie in der folgenden Zeile (angepasst an eine andere Antwort von Benutzer Bufke zur manuellen Vorgehensweise ) einen vernünftigen Wert (in Zeichenbreiten) angeben:

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

Es gibt ein schönes Paket, das ich kürzlich verwendet habe und das StyleFrame heißt.

Es erhält DataFrame und ermöglicht es Ihnen, es sehr einfach zu gestalten ...

Standardmäßig wird die Spaltenbreite automatisch angepasst.

beispielsweise:

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

Sie können auch die Spaltenbreite ändern:

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

AKTUALISIEREN

In Version 1.4 wurde das best_fitArgument hinzugefügt StyleFrame.to_excel. Siehe die Dokumentation .

Mit Pandas und xlsxwriter können Sie Ihre Aufgabe erledigen. Der folgende Code funktioniert perfekt in Python 3.x. Weitere Informationen zum Arbeiten mit XlsxWriter mit Pandas finden Sie unter 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()

Bei der Arbeit schreibe ich immer die Datenrahmen, um Dateien zu übertreffen. Anstatt immer wieder denselben Code zu schreiben, habe ich einen Modul erstellt. Jetzt importiere ich es einfach und benutze es, um die Excel-Dateien zu schreiben und zu formatieren. Es gibt jedoch einen Nachteil: Es dauert lange, wenn der Datenrahmen besonders groß ist. Also hier ist der 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

Ich fand, dass es nützlicher war, die Spalte basierend auf der Spaltenüberschrift anzupassen, als den Spalteninhalt.

Mit df.columns.values.tolist()I generiere ich eine Liste der Spaltenüberschriften und benutze die Länge dieser Überschriften, um die Breite der Spalten zu bestimmen.

Siehe den vollständigen Code unten:

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

Passen Sie alle Spaltenlängen dynamisch an

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)

Passen Sie eine Spalte manuell mit dem Spaltennamen an

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

Passen Sie eine Spalte mithilfe des Spaltenindex manuell an

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

Falls einer der oben genannten Fehler auftritt

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

Stellen Sie sicher, dass Sie Folgendes installieren xlsxwriter:

pip install xlsxwriter

Kombinieren Sie die anderen Antworten und Kommentare und unterstützen Sie auch Multi-Indizes:

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

Die einfachste Lösung besteht darin, die Spaltenbreite in der Methode set_column anzugeben.

    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)