Vergleichen Sie zwei DataFrames und geben Sie ihre Unterschiede nebeneinander aus

162

Ich versuche genau hervorzuheben, was sich zwischen zwei Datenrahmen geändert hat.

Angenommen, ich habe zwei Python Pandas-Datenrahmen:

"StudentRoster Jan-1":
id   Name   score                    isEnrolled           Comment
111  Jack   2.17                     True                 He was late to class
112  Nick   1.11                     False                Graduated
113  Zoe    4.12                     True       

"StudentRoster Jan-2":
id   Name   score                    isEnrolled           Comment
111  Jack   2.17                     True                 He was late to class
112  Nick   1.21                     False                Graduated
113  Zoe    4.12                     False                On vacation

Mein Ziel ist es, eine HTML-Tabelle auszugeben, die:

  1. Identifiziert geänderte Zeilen (int, float, boolean, string)
  2. Gibt Zeilen mit denselben, ALTEN und NEUEN Werten aus (idealerweise in eine HTML-Tabelle), damit der Verbraucher klar erkennen kann, was sich zwischen zwei Datenrahmen geändert hat:

    "StudentRoster Difference Jan-1 - Jan-2":  
    id   Name   score                    isEnrolled           Comment
    112  Nick   was 1.11| now 1.21       False                Graduated
    113  Zoe    4.12                     was True | now False was "" | now   "On   vacation"

Ich nehme an, ich könnte einen zeilenweisen und einen spaltenweisen Vergleich durchführen, aber gibt es einen einfacheren Weg?

Himmel
quelle
Ab Pandas 1.1 können Sie dies ganz einfach mit einem einzigen Funktionsaufrufdf.compare tun - .
cs95

Antworten:

153

Der erste Teil ähnelt Constantine. Sie können den Booleschen Wert ermitteln, dessen Zeilen leer sind *:

In [21]: ne = (df1 != df2).any(1)

In [22]: ne
Out[22]:
0    False
1     True
2     True
dtype: bool

Dann können wir sehen, welche Einträge sich geändert haben:

In [23]: ne_stacked = (df1 != df2).stack()

In [24]: changed = ne_stacked[ne_stacked]

In [25]: changed.index.names = ['id', 'col']

In [26]: changed
Out[26]:
id  col
1   score         True
2   isEnrolled    True
    Comment       True
dtype: bool

Hier ist der erste Eintrag der Index und der zweite die geänderten Spalten.

In [27]: difference_locations = np.where(df1 != df2)

In [28]: changed_from = df1.values[difference_locations]

In [29]: changed_to = df2.values[difference_locations]

In [30]: pd.DataFrame({'from': changed_from, 'to': changed_to}, index=changed.index)
Out[30]:
               from           to
id col
1  score       1.11         1.21
2  isEnrolled  True        False
   Comment     None  On vacation

* Hinweis: Es ist wichtig , dass df1und df2hier den gleichen Index teilen. Um diese Unklarheit zu überwinden, können Sie sicherstellen, dass Sie nur die freigegebenen Labels mit verwenden df1.index & df2.index, aber ich denke, ich werde das als Übung belassen.

Andy Hayden
quelle
2
Ich glaube, "denselben Index teilen" bedeutet "sicherstellen, dass der Index sortiert ist" ... dies vergleicht alles df1, was zuerst kommt df2, mit dem , was zuerst kommt , unabhängig vom Wert des Index. JFYI für den Fall, dass ich nicht die einzige Person bin, für die dies nicht offensichtlich war. ; D Danke!
dmn
12
Wenn Punktzahl gleich nanin beiden DF1 und df1, wird diese Funktion berichten sie , wie aus geändert haben nanzu nan. Dies liegt daran, dass np.nan != np.nanzurückgegeben wird True.
James Owers
2
@kungfujam ist richtig. Wenn die zu vergleichenden Werte Keine sind, erhalten Sie auch dort falsche Unterschiede
FistOfFury
Nur um klar zu sein - ich das Problem mit dieser Lösung zeigen und bieten eine einfache Funktion zu verwenden , die das Problem behebt unten
James Owers
1
['row', 'col'] ist gegenüber geänderten.index.names vorzuziehen als ['id', 'col'], da es sich nicht um IDs, sondern um Zeilen handelt.
Naoki Fujita
87

Hervorheben des Unterschieds zwischen zwei DataFrames

Mit der DataFrame-Stileigenschaft können Sie die Hintergrundfarbe der Zellen hervorheben, bei denen ein Unterschied besteht.

Verwenden Sie die Beispieldaten aus der ursprünglichen Frage

Der erste Schritt besteht darin, die DataFrames horizontal mit der concatFunktion zu verketten und jeden Frame mit dem keysParameter zu unterscheiden:

df_all = pd.concat([df.set_index('id'), df2.set_index('id')], 
                   axis='columns', keys=['First', 'Second'])
df_all

Geben Sie hier die Bildbeschreibung ein

Es ist wahrscheinlich einfacher, die Spaltenebenen zu vertauschen und dieselben Spaltennamen nebeneinander zu platzieren:

df_final = df_all.swaplevel(axis='columns')[df.columns[1:]]
df_final

Geben Sie hier die Bildbeschreibung ein

Jetzt ist es viel einfacher, die Unterschiede in den Frames zu erkennen. Wir können jedoch noch weiter gehen und die styleEigenschaft verwenden, um die unterschiedlichen Zellen hervorzuheben. Dazu definieren wir eine benutzerdefinierte Funktion, die Sie in diesem Teil der Dokumentation sehen können .

def highlight_diff(data, color='yellow'):
    attr = 'background-color: {}'.format(color)
    other = data.xs('First', axis='columns', level=-1)
    return pd.DataFrame(np.where(data.ne(other, level=0), attr, ''),
                        index=data.index, columns=data.columns)

df_final.style.apply(highlight_diff, axis=None)

Geben Sie hier die Bildbeschreibung ein

Dadurch werden Zellen hervorgehoben, bei denen beide Werte fehlen. Sie können sie entweder füllen oder zusätzliche Logik bereitstellen, damit sie nicht hervorgehoben werden.

Ted Petrou
quelle
1
Wissen Sie, wie es möglich ist, sowohl 'First' als auch 'Second' in verschiedenen Farben zu färben?
Aturegano
1
Ist es möglich, nur verschiedene Zeilen auszuwählen? Wie wähle ich in diesem Fall die zweite und dritte Reihe aus, ohne die erste Reihe (111) auszuwählen?
Shantanuo
1
@ Shantanuo, ja, bearbeiten Sie einfach die endgültige Methode zudf_final[(df != df2).any(1)].style.apply(highlight_diff, axis=None)
anmol
3
Diese Implementierung dauert länger, wenn Datenrahmen mit 26 KB Zeilen und 400 Spalten verglichen werden. Gibt es eine Möglichkeit, es zu beschleunigen?
Codeslord
42

Diese Antwort erweitert einfach @Andy Haydens, macht es widerstandsfähig gegenüber numerischen Feldern nanund verpackt es in eine Funktion.

import pandas as pd
import numpy as np


def diff_pd(df1, df2):
    """Identify differences between two pandas DataFrames"""
    assert (df1.columns == df2.columns).all(), \
        "DataFrame column names are different"
    if any(df1.dtypes != df2.dtypes):
        "Data Types are different, trying to convert"
        df2 = df2.astype(df1.dtypes)
    if df1.equals(df2):
        return None
    else:
        # need to account for np.nan != np.nan returning True
        diff_mask = (df1 != df2) & ~(df1.isnull() & df2.isnull())
        ne_stacked = diff_mask.stack()
        changed = ne_stacked[ne_stacked]
        changed.index.names = ['id', 'col']
        difference_locations = np.where(diff_mask)
        changed_from = df1.values[difference_locations]
        changed_to = df2.values[difference_locations]
        return pd.DataFrame({'from': changed_from, 'to': changed_to},
                            index=changed.index)

Also mit Ihren Daten (leicht bearbeitet, um eine NaN in der Bewertungsspalte zu haben):

import sys
if sys.version_info[0] < 3:
    from StringIO import StringIO
else:
    from io import StringIO

DF1 = StringIO("""id   Name   score                    isEnrolled           Comment
111  Jack   2.17                     True                 "He was late to class"
112  Nick   1.11                     False                "Graduated"
113  Zoe    NaN                     True                  " "
""")
DF2 = StringIO("""id   Name   score                    isEnrolled           Comment
111  Jack   2.17                     True                 "He was late to class"
112  Nick   1.21                     False                "Graduated"
113  Zoe    NaN                     False                "On vacation" """)
df1 = pd.read_table(DF1, sep='\s+', index_col='id')
df2 = pd.read_table(DF2, sep='\s+', index_col='id')
diff_pd(df1, df2)

Ausgabe:

                from           to
id  col                          
112 score       1.11         1.21
113 isEnrolled  True        False
    Comment           On vacation
James Owers
quelle
Ich habe Code hinzugefügt, um kleinere Unterschiede im Datentyp zu beseitigen, die einen Fehler auslösen würden, wenn Sie dies nicht berücksichtigen würden.
Roobie Nuby
Was ist, wenn ich auf beiden Seiten keine identischen Zeilen zum Vergleichen habe?
Kishor Kumar R
@KishorkumarR dann sollten Sie zuerst die Zeilen ausgleichen, indem Sie dem neuen Datenrahmen hinzugefügte Zeilen erkennen und Zeilen aus dem alten Datenrahmen entfernen
Sabre
22
import pandas as pd
import io

texts = ['''\
id   Name   score                    isEnrolled                        Comment
111  Jack   2.17                     True                 He was late to class
112  Nick   1.11                     False                           Graduated
113  Zoe    4.12                     True       ''',

         '''\
id   Name   score                    isEnrolled                        Comment
111  Jack   2.17                     True                 He was late to class
112  Nick   1.21                     False                           Graduated
113  Zoe    4.12                     False                         On vacation''']


df1 = pd.read_fwf(io.StringIO(texts[0]), widths=[5,7,25,21,20])
df2 = pd.read_fwf(io.StringIO(texts[1]), widths=[5,7,25,21,20])
df = pd.concat([df1,df2]) 

print(df)
#     id  Name  score isEnrolled               Comment
# 0  111  Jack   2.17       True  He was late to class
# 1  112  Nick   1.11      False             Graduated
# 2  113   Zoe   4.12       True                   NaN
# 0  111  Jack   2.17       True  He was late to class
# 1  112  Nick   1.21      False             Graduated
# 2  113   Zoe   4.12      False           On vacation

df.set_index(['id', 'Name'], inplace=True)
print(df)
#           score isEnrolled               Comment
# id  Name                                        
# 111 Jack   2.17       True  He was late to class
# 112 Nick   1.11      False             Graduated
# 113 Zoe    4.12       True                   NaN
# 111 Jack   2.17       True  He was late to class
# 112 Nick   1.21      False             Graduated
# 113 Zoe    4.12      False           On vacation

def report_diff(x):
    return x[0] if x[0] == x[1] else '{} | {}'.format(*x)

changes = df.groupby(level=['id', 'Name']).agg(report_diff)
print(changes)

druckt

                score    isEnrolled               Comment
id  Name                                                 
111 Jack         2.17          True  He was late to class
112 Nick  1.11 | 1.21         False             Graduated
113 Zoe          4.12  True | False     nan | On vacation
unutbu
quelle
3
Sehr schöne Lösung, viel kompakter als meine!
Andy Hayden
1
@AndyHayden: Ich bin mit dieser Lösung nicht ganz zufrieden. Es scheint nur zu funktionieren, wenn der Index ein mehrstufiger Index ist. Wenn ich versuche, nur idals Index zu verwenden, wird df.groupby(level='id')ein Fehler
ausgegeben
19

Ich habe mich diesem Problem gestellt, aber eine Antwort gefunden, bevor ich diesen Beitrag gefunden habe:

Laden Sie Ihre Daten basierend auf der Antwort von unutbu ...

import pandas as pd
import io

texts = ['''\
id   Name   score                    isEnrolled                       Date
111  Jack                            True              2013-05-01 12:00:00
112  Nick   1.11                     False             2013-05-12 15:05:23
     Zoe    4.12                     True                                  ''',

         '''\
id   Name   score                    isEnrolled                       Date
111  Jack   2.17                     True              2013-05-01 12:00:00
112  Nick   1.21                     False                                
     Zoe    4.12                     False             2013-05-01 12:00:00''']


df1 = pd.read_fwf(io.StringIO(texts[0]), widths=[5,7,25,17,20], parse_dates=[4])
df2 = pd.read_fwf(io.StringIO(texts[1]), widths=[5,7,25,17,20], parse_dates=[4])

... definieren Sie Ihre Diff- Funktion ...

def report_diff(x):
    return x[0] if x[0] == x[1] else '{} | {}'.format(*x)

Dann können Sie einfach ein Panel verwenden, um Folgendes zu schließen:

my_panel = pd.Panel(dict(df1=df1,df2=df2))
print my_panel.apply(report_diff, axis=0)

#          id  Name        score    isEnrolled                       Date
#0        111  Jack   nan | 2.17          True        2013-05-01 12:00:00
#1        112  Nick  1.11 | 1.21         False  2013-05-12 15:05:23 | NaT
#2  nan | nan   Zoe         4.12  True | False  NaT | 2013-05-01 12:00:00

Übrigens, wenn Sie sich in IPython Notebook befinden, können Sie eine farbige Diff- Funktion verwenden, um Farben zu geben, je nachdem, ob die Zellen unterschiedlich, gleich oder links / rechts null sind:

from IPython.display import HTML
pd.options.display.max_colwidth = 500  # You need this, otherwise pandas
#                          will limit your HTML strings to 50 characters

def report_diff(x):
    if x[0]==x[1]:
        return unicode(x[0].__str__())
    elif pd.isnull(x[0]) and pd.isnull(x[1]):
        return u'<table style="background-color:#00ff00;font-weight:bold;">'+\
            '<tr><td>%s</td></tr><tr><td>%s</td></tr></table>' % ('nan', 'nan')
    elif pd.isnull(x[0]) and ~pd.isnull(x[1]):
        return u'<table style="background-color:#ffff00;font-weight:bold;">'+\
            '<tr><td>%s</td></tr><tr><td>%s</td></tr></table>' % ('nan', x[1])
    elif ~pd.isnull(x[0]) and pd.isnull(x[1]):
        return u'<table style="background-color:#0000ff;font-weight:bold;">'+\
            '<tr><td>%s</td></tr><tr><td>%s</td></tr></table>' % (x[0],'nan')
    else:
        return u'<table style="background-color:#ff0000;font-weight:bold;">'+\
            '<tr><td>%s</td></tr><tr><td>%s</td></tr></table>' % (x[0], x[1])

HTML(my_panel.apply(report_diff, axis=0).to_html(escape=False))
Journois
quelle
(In normalem Python, nicht in iPython Notebook) Ist es möglich, in my_panel = pd.Panel(dict(df1=df1,df2=df2))die Funktion aufzunehmen report_diff()? Ich meine, ist es möglich, dies zu tun: print report_diff(df1,df2)und die gleiche Ausgabe wie Ihre Druckanweisung zu erhalten?
Edesz
pd.Panel(dict(df1=df1,df2=df2)).apply(report_diff, axis=0)- das ist fantastisch!!!
MaxU
5
Panels sind veraltet! Irgendeine Idee, wie man das portiert?
Denfromufa
@denfromufa Ich habe versucht, es in meiner Antwort zu aktualisieren: stackoverflow.com/a/49038417/7607701
Aaron N. Brock
9

Wenn Ihre beiden Datenrahmen dieselben IDs enthalten, ist es eigentlich ziemlich einfach herauszufinden, was sich geändert hat. frame1 != frame2Wenn Sie dies tun , erhalten Sie einen booleschen DataFrame, in dem sich alle TrueDaten geändert haben. Daraus können Sie leicht den Index jeder geänderten Zeile abrufen, indem Sie dies tun changedids = frame1.index[np.any(frame1 != frame2,axis=1)].

cge
quelle
6

Ein anderer Ansatz mit concat und drop_duplicates:

import sys
if sys.version_info[0] < 3:
    from StringIO import StringIO
else:
    from io import StringIO
import pandas as pd

DF1 = StringIO("""id   Name   score                    isEnrolled           Comment
111  Jack   2.17                     True                 "He was late to class"
112  Nick   1.11                     False                "Graduated"
113  Zoe    NaN                     True                  " "
""")
DF2 = StringIO("""id   Name   score                    isEnrolled           Comment
111  Jack   2.17                     True                 "He was late to class"
112  Nick   1.21                     False                "Graduated"
113  Zoe    NaN                     False                "On vacation" """)

df1 = pd.read_table(DF1, sep='\s+', index_col='id')
df2 = pd.read_table(DF2, sep='\s+', index_col='id')
#%%
dictionary = {1:df1,2:df2}
df=pd.concat(dictionary)
df.drop_duplicates(keep=False)

Ausgabe:

       Name  score isEnrolled      Comment
  id                                      
1 112  Nick   1.11      False    Graduated
  113   Zoe    NaN       True             
2 112  Nick   1.21      False    Graduated
  113   Zoe    NaN      False  On vacation
jur
quelle
3

Nachdem ich mit der Antwort von @ journois herumgespielt hatte, konnte ich sie aufgrund der Deprivation von Panel mit MultiIndex anstelle von Panel zum Laufen bringen .

Erstellen Sie zunächst einige Dummy-Daten:

df1 = pd.DataFrame({
    'id': ['111', '222', '333', '444', '555'],
    'let': ['a', 'b', 'c', 'd', 'e'],
    'num': ['1', '2', '3', '4', '5']
})
df2 = pd.DataFrame({
    'id': ['111', '222', '333', '444', '666'],
    'let': ['a', 'b', 'c', 'D', 'f'],
    'num': ['1', '2', 'Three', '4', '6'],
})

Definieren Sie dann Ihre Diff- Funktion. In diesem Fall verwende ich die aus seiner Antwort. report_diffBleibt gleich:

def report_diff(x):
    return x[0] if x[0] == x[1] else '{} | {}'.format(*x)

Dann werde ich die Daten zu einem MultiIndex-Datenrahmen verketten:

df_all = pd.concat(
    [df1.set_index('id'), df2.set_index('id')], 
    axis='columns', 
    keys=['df1', 'df2'],
    join='outer'
)
df_all = df_all.swaplevel(axis='columns')[df1.columns[1:]]

Und zum Schluss werde ich report_diffjede Spaltengruppe nach unten anwenden :

df_final.groupby(level=0, axis=1).apply(lambda frame: frame.apply(report_diff, axis=1))

Dies gibt aus:

         let        num
111        a          1
222        b          2
333        c  3 | Three
444    d | D          4
555  e | nan    5 | nan
666  nan | f    nan | 6

Und das ist alles!

Aaron N. Brock
quelle
3

Erweiterte Antwort von @cge, die für eine bessere Lesbarkeit des Ergebnisses ziemlich cool ist:

a[a != b][np.any(a != b, axis=1)].join(pd.DataFrame('a<->b', index=a.index, columns=['a<=>b'])).join(
        b[a != b][np.any(a != b, axis=1)]
        ,rsuffix='_b', how='outer'
).fillna('')

Vollständiges Demonstrationsbeispiel:

import numpy as np, pandas as pd

a = pd.DataFrame(np.random.randn(7,3), columns=list('ABC'))
b = a.copy()
b.iloc[0,2] = np.nan
b.iloc[1,0] = 7
b.iloc[3,1] = 77
b.iloc[4,2] = 777

a[a != b][np.any(a != b, axis=1)].join(pd.DataFrame('a<->b', index=a.index, columns=['a<=>b'])).join(
        b[a != b][np.any(a != b, axis=1)]
        ,rsuffix='_b', how='outer'
).fillna('')
Hubbitus
quelle
1

Hier ist eine andere Möglichkeit, Select und Merge zu verwenden:

In [6]: # first lets create some dummy dataframes with some column(s) different
   ...: df1 = pd.DataFrame({'a': range(-5,0), 'b': range(10,15), 'c': range(20,25)})
   ...: df2 = pd.DataFrame({'a': range(-5,0), 'b': range(10,15), 'c': [20] + list(range(101,105))})


In [7]: df1
Out[7]:
   a   b   c
0 -5  10  20
1 -4  11  21
2 -3  12  22
3 -2  13  23
4 -1  14  24


In [8]: df2
Out[8]:
   a   b    c
0 -5  10   20
1 -4  11  101
2 -3  12  102
3 -2  13  103
4 -1  14  104


In [10]: # make condition over the columns you want to comapre
    ...: condition = df1['c'] != df2['c']
    ...:
    ...: # select rows from each dataframe where the condition holds
    ...: diff1 = df1[condition]
    ...: diff2 = df2[condition]


In [11]: # merge the selected rows (dataframes) with some suffixes (optional)
    ...: diff1.merge(diff2, on=['a','b'], suffixes=('_before', '_after'))
Out[11]:
   a   b  c_before  c_after
0 -4  11        21      101
1 -3  12        22      102
2 -2  13        23      103
3 -1  14        24      104

Hier ist das gleiche aus einem Jupyter-Screenshot:

Geben Sie hier die Bildbeschreibung ein

Aziz Alto
quelle
0

Pandas> = 1,1: DataFrame.compare

Mit pandas 1.1 können Sie die Ausgabe von Ted Petrou im Wesentlichen mit einem einzigen Funktionsaufruf replizieren. Beispiel aus den Dokumenten:

pd.__version__
# '1.1.0.dev0+2004.g8d10bfb6f'

df1.compare(df2)

  score       isEnrolled       Comment             
   self other       self other    self        other
1  1.11  1.21        NaN   NaN     NaN          NaN
2   NaN   NaN        1.0   0.0     NaN  On vacation

Hier bezieht sich "self" auf den LHS-Datenrahmen, während "other" auf den RHS-Datenrahmen verweist. Standardmäßig werden gleiche Werte durch NaNs ersetzt, sodass Sie sich nur auf die Unterschiede konzentrieren können. Wenn Sie auch gleiche Werte anzeigen möchten, verwenden Sie

df1.compare(df2, keep_equal=True, keep_shape=True) 

  score       isEnrolled           Comment             
   self other       self  other       self        other
1  1.11  1.21      False  False  Graduated    Graduated
2  4.12  4.12       True  False        NaN  On vacation

Sie können die Vergleichsachse auch ändern mit align_axis:

df1.compare(df2, align_axis='index')

         score  isEnrolled      Comment
1 self    1.11         NaN          NaN
  other   1.21         NaN          NaN
2 self     NaN         1.0          NaN
  other    NaN         0.0  On vacation

Dies vergleicht die Werte zeilenweise statt spaltenweise.

cs95
quelle
Hinweis: pandas 1.1 ist noch experimentell und nur durch Erstellen einer Entwicklungssandbox verfügbar .
cs95
-1

Eine Funktion, die einen asymmetrischen Unterschied zwischen zwei Datenrahmen findet, ist unten implementiert: (Basierend auf dem eingestellten Unterschied für Pandas ) GIST: https://gist.github.com/oneryalcin/68cf25f536a25e65f0b3c84f9c118e03

def diff_df(df1, df2, how="left"):
    """
      Find Difference of rows for given two dataframes
      this function is not symmetric, means
            diff(x, y) != diff(y, x)
      however
            diff(x, y, how='left') == diff(y, x, how='right')

      Ref: /programming/18180763/set-difference-for-pandas/40209800#40209800
    """
    if (df1.columns != df2.columns).any():
        raise ValueError("Two dataframe columns must match")

    if df1.equals(df2):
        return None
    elif how == 'right':
        return pd.concat([df2, df1, df1]).drop_duplicates(keep=False)
    elif how == 'left':
        return pd.concat([df1, df2, df2]).drop_duplicates(keep=False)
    else:
        raise ValueError('how parameter supports only "left" or "right keywords"')

Beispiel:

df1 = pd.DataFrame(d1)
Out[1]: 
                Comment  Name  isEnrolled  score
0  He was late to class  Jack        True   2.17
1             Graduated  Nick       False   1.11
2                         Zoe        True   4.12


df2 = pd.DataFrame(d2)

Out[2]: 
                Comment  Name  isEnrolled  score
0  He was late to class  Jack        True   2.17
1           On vacation   Zoe        True   4.12

diff_df(df1, df2)
Out[3]: 
     Comment  Name  isEnrolled  score
1  Graduated  Nick       False   1.11
2              Zoe        True   4.12

diff_df(df2, df1)
Out[4]: 
       Comment Name  isEnrolled  score
1  On vacation  Zoe        True   4.12

# This gives the same result as above
diff_df(df1, df2, how='right')
Out[22]: 
       Comment Name  isEnrolled  score
1  On vacation  Zoe        True   4.12
Mehmet Öner Yalçın
quelle
-1

Pandas als pd importieren numpy als np importieren

df = pd.read_excel ('D: \ HARISH \ DATA SCIENCE \ 1 MEIN Training \ MUSTERDATEN & projs \ KRICKETDATEN \ IPL-SPIELERLISTE \ IPL-SPIELERLISTE _ harish.xlsx')

df1 = srh = df [df ['TEAM']. str.contains ("SRH")] df2 = csk = df [df ['TEAM']. str.contains ("CSK")]

srh = srh.iloc [:, 0: 2] csk = csk.iloc [:, 0: 2]

csk = csk.reset_index (drop = True) csk

srh = srh.reset_index (drop = True) srh

new = pd.concat ([srh, csk], axis = 1)

new.head ()

** SPIELERTYP SPIELERTYP

0 David Warner Batsman ... MS Dhoni Kapitän

1 Bhuvaneshwar Kumar Bowler ... Ravindra Jadeja Allrounder

2 Manish Pandey Batsman ... Suresh Raina Allrounder

3 Rashid Khan Arman Bowler ... Kedar Jadhav Allrounder

4 Shikhar Dhawan Batsman .... Dwayne Bravo Allrounder

HARISH TRASH
quelle
Spieler - Typ Spieler - Typ 0 David Warner Batsman MS Dhoni Kapitän 1 Bhuvaneshwar Kumar Bowler Ravindra Jadeja All-Rounder 2 Manish Pandey Batsman Suresh Raina All-Rounder 3 Rashid Khan Arman Bowler Kedar Jadhav All-Rounder 4 Shikhar Dhawan Batsman Dwayne Bravo All-Rounder
HARISH Müll
Hallo Harish, bitte formatiere deine Antwort etwas mehr, sonst ist es ziemlich schwer zu lesen :)
Markus