Das Jupyter-Notizbuch zeigt zwei Pandas-Tische nebeneinander an

Ich habe zwei Pandas-Datenrahmen und möchte sie im Jupyter-Notizbuch anzeigen.

So etwas tun wie:

display(df1)
display(df2)

Zeigt sie untereinander:

Ich hätte gerne einen zweiten Datenrahmen rechts vom ersten. Es gibt eine ähnliche Frage , aber es sieht so aus, als ob eine Person damit zufrieden ist, sie in einem Datenrahmen zusammenzuführen, um den Unterschied zwischen ihnen zu zeigen.

Das wird bei mir nicht funktionieren. In meinem Fall können Datenrahmen völlig unterschiedliche (nicht vergleichbare) Elemente darstellen und ihre Größe kann unterschiedlich sein. Mein Hauptziel ist es daher, Platz zu sparen.

Sie können das CSS des Ausgabecodes überschreiben. Es flex-direction: columnwird standardmäßig verwendet. Versuchen Sie es rowstattdessen zu ändern . Hier ist ein Beispiel:

import pandas as pd
import numpy as np
from IPython.display import display, HTML

CSS = """
.output {
    flex-direction: row;
}
"""

HTML('<style>{}</style>'.format(CSS))

Sie können das CSS natürlich weiter anpassen, wie Sie möchten.

Wenn Sie nur auf die Ausgabe einer Zelle abzielen möchten, verwenden Sie den :nth-child()Selektor. Mit diesem Code wird beispielsweise das CSS der Ausgabe nur der 5. Zelle im Notizbuch geändert:

CSS = """
div.cell:nth-child(5) .output {
    flex-direction: row;
}
"""

Am Ende habe ich eine Funktion geschrieben, die dies kann:

from IPython.display import display_html
def display_side_by_side(*args):
    html_str=''
    for df in args:
        html_str+=df.to_html()
    display_html(html_str.replace('table','table style="display:inline"'),raw=True)

Anwendungsbeispiel:

df1 = pd.DataFrame(np.arange(12).reshape((3,4)),columns=['A','B','C','D',])
df2 = pd.DataFrame(np.arange(16).reshape((4,4)),columns=['A','B','C','D',])
display_side_by_side(df1,df2,df1)

Ausgehend von pandas 0.17.1der Visualisierung von DataFrames können direkt mit Pandas-Styling-Methoden geändert werden

Um zwei DataFrames nebeneinander anzuzeigen, müssen Sie set_table_attributesdas "style='display:inline'"in ntg answer vorgeschlagene Argument verwenden . Dies gibt zwei StylerObjekte zurück. Um die ausgerichteten Datenrahmen anzuzeigen, übergeben Sie einfach ihre verknüpfte HTML-Darstellung durch diedisplay_html Methode von IPython.

Mit dieser Methode ist es auch einfacher, andere Styling-Optionen hinzuzufügen. So fügen Sie eine Beschriftung hinzu, wie hier angefordert :

import numpy as np
import pandas as pd   
from IPython.display import display_html 

df1 = pd.DataFrame(np.arange(12).reshape((3,4)),columns=['A','B','C','D',])
df2 = pd.DataFrame(np.arange(16).reshape((4,4)),columns=['A','B','C','D',])

df1_styler = df1.style.set_table_attributes("style='display:inline'").set_caption('Caption table 1')
df2_styler = df2.style.set_table_attributes("style='display:inline'").set_caption('Caption table 2')

display_html(df1_styler._repr_html_()+df2_styler._repr_html_(), raw=True)

Durch die Kombination der Ansätze von Gibbone (zum Festlegen von Stilen und Beschriftungen) und Stevi (Hinzufügen von Speicherplatz) habe ich meine Funktionsversion erstellt, die Pandas-Datenrahmen als Tabellen nebeneinander ausgibt:

from IPython.core.display import display, HTML

def display_side_by_side(dfs:list, captions:list):
    """Display tables side by side to save vertical space
    Input:
        dfs: list of pandas.DataFrame
        captions: list of table captions
    """
    output = ""
    combined = dict(zip(captions, dfs))
    for caption, df in combined.items():
        output += df.style.set_table_attributes("style='display:inline'").set_caption(caption)._repr_html_()
        output += "\xa0\xa0\xa0"
    display(HTML(output))

Verwendung:

display_side_by_side([df1, df2, df3], ['caption1', 'caption2', 'caption3'])

Ausgabe:

Hier ist die Lösung von Jake Vanderplas, auf die ich neulich gestoßen bin:

import numpy as np
import pandas as pd

class display(object):
    """Display HTML representation of multiple objects"""
    template = """<div style="float: left; padding: 10px;">
    <p style='font-family:"Courier New", Courier, monospace'>{0}</p>{1}
    </div>"""

    def __init__(self, *args):
        self.args = args

    def _repr_html_(self):
        return '\n'.join(self.template.format(a, eval(a)._repr_html_())
                     for a in self.args)

    def __repr__(self):
       return '\n\n'.join(a + '\n' + repr(eval(a))
                       for a in self.args)

Bildnachweis: https://github.com/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/03.08-Aggregation-and-Grouping.ipynb

Meine Lösung erstellt einfach eine Tabelle in HTML ohne CSS-Hacks und gibt sie aus:

import pandas as pd
from IPython.display import display,HTML

def multi_column_df_display(list_dfs, cols=3):
    html_table = "<table style='width:100%; border:0px'>{content}</table>"
    html_row = "<tr style='border:0px'>{content}</tr>"
    html_cell = "<td style='width:{width}%;vertical-align:top;border:0px'>{{content}}</td>"
    html_cell = html_cell.format(width=100/cols)

    cells = [ html_cell.format(content=df.to_html()) for df in list_dfs ]
    cells += (cols - (len(list_dfs)%cols)) * [html_cell.format(content="")] # pad
    rows = [ html_row.format(content="".join(cells[i:i+cols])) for i in range(0,len(cells),cols)]
    display(HTML(html_table.format(content="".join(rows))))

list_dfs = []
list_dfs.append( pd.DataFrame(2*[{"x":"hello"}]) )
list_dfs.append( pd.DataFrame(2*[{"x":"world"}]) )
multi_column_df_display(2*list_dfs)

Dies fügt der Antwort von @ nts Header hinzu:

from IPython.display import display_html

def mydisplay(dfs, names=[]):
    html_str = ''
    if names:
        html_str += ('<tr>' + 
                     ''.join(f'<td style="text-align:center">{name}</td>' for name in names) + 
                     '</tr>')
    html_str += ('<tr>' + 
                 ''.join(f'<td style="vertical-align:top"> {df.to_html(index=False)}</td>' 
                         for df in dfs) + 
                 '</tr>')
    html_str = f'<table>{html_str}</table>'
    html_str = html_str.replace('table','table style="display:inline"')
    display_html(html_str, raw=True)

Am Ende habe ich HBOX verwendet

import ipywidgets as ipyw

def get_html_table(target_df, title):
    df_style = target_df.style.set_table_attributes("style='border:2px solid;font-size:10px;margin:10px'").set_caption(title)
    return df_style._repr_html_()

df_2_html_table = get_html_table(df_2, 'Data from Google Sheet')
df_4_html_table = get_html_table(df_4, 'Data from Jira')
ipyw.HBox((ipyw.HTML(df_2_html_table),ipyw.HTML(df_4_html_table)))

Gibbones Antwort hat bei mir funktioniert! Wenn Sie zusätzlichen Platz zwischen den Tabellen wünschen, gehen Sie zu dem von ihm vorgeschlagenen Code und fügen Sie diesen "\xa0\xa0\xa0"der folgenden Codezeile hinzu.

display_html(df1_styler._repr_html_()+"\xa0\xa0\xa0"+df2_styler._repr_html_(), raw=True)

Ich beschloss, Yasins elegante Antwort um einige zusätzliche Funktionen zu erweitern, bei denen man sowohl die Anzahl der Spalten als auch die Zeilen auswählen kann . Alle zusätzlichen dfs werden dann unten hinzugefügt. Zusätzlich kann man wählen, in welcher Reihenfolge das Raster gefüllt werden soll (ändern Sie einfach das Füllschlüsselwort in "Spalten" oder "Zeilen", je nach Bedarf).

import pandas as pd
from IPython.display import display,HTML

def grid_df_display(list_dfs, rows = 2, cols=3, fill = 'cols'):
    html_table = "<table style='width:100%; border:0px'>{content}</table>"
    html_row = "<tr style='border:0px'>{content}</tr>"
    html_cell = "<td style='width:{width}%;vertical-align:top;border:0px'>{{content}}</td>"
    html_cell = html_cell.format(width=100/cols)

    cells = [ html_cell.format(content=df.to_html()) for df in list_dfs[:rows*cols] ]
    cells += cols * [html_cell.format(content="")] # pad

    if fill == 'rows': #fill in rows first (first row: 0,1,2,... col-1)
        grid = [ html_row.format(content="".join(cells[i:i+cols])) for i in range(0,rows*cols,cols)]

    if fill == 'cols': #fill columns first (first column: 0,1,2,..., rows-1)
        grid = [ html_row.format(content="".join(cells[i:rows*cols:rows])) for i in range(0,rows)]

    display(HTML(html_table.format(content="".join(grid))))

    #add extra dfs to bottom
    [display(list_dfs[i]) for i in range(rows*cols,len(list_dfs))]

list_dfs = []
list_dfs.extend((pd.DataFrame(2*[{"x":"hello"}]), 
             pd.DataFrame(2*[{"x":"world"}]), 
             pd.DataFrame(2*[{"x":"gdbye"}])))

grid_df_display(3*list_dfs)

Testausgabe

Erweiterung der Antwort von antony Wenn Sie die Visualisierung von Tabellen auf eine bestimmte Anzahl von Blöcken pro Zeile beschränken möchten, verwenden Sie die Variable maxTables.

def mydisplay(dfs, names=[]):

    count = 0
    maxTables = 6

    if not names:
        names = [x for x in range(len(dfs))]

    html_str = ''
    html_th = ''
    html_td = ''

    for df, name in zip(dfs, names):
        if count <= (maxTables):
            html_th += (''.join(f'<th style="text-align:center">{name}</th>'))
            html_td += (''.join(f'<td style="vertical-align:top"> {df.to_html(index=False)}</td>'))
            count += 1
        else:
            html_str += f'<tr>{html_th}</tr><tr>{html_td}</tr>'
            html_th = f'<th style="text-align:center">{name}</th>'
            html_td = f'<td style="vertical-align:top"> {df.to_html(index=False)}</td>'
            count = 0


    if count != 0:
        html_str += f'<tr>{html_th}</tr><tr>{html_td}</tr>'


    html_str += f'<table>{html_str}</table>'
    html_str = html_str.replace('table','table style="display:inline"')
    display_html(html_str, raw=True)