Python cetak dua kolom berdampingan

Beberapa studi data yang paling menarik berasal dari penggabungan berbagai sumber data. Operasi ini dapat melibatkan apa saja mulai dari penggabungan yang sangat mudah dari dua set data yang berbeda, hingga penggabungan dan penggabungan gaya database yang lebih rumit yang menangani dengan benar setiap tumpang tindih antara set data.

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)
    
1 dan
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)
    
2 dibangun dengan mempertimbangkan jenis operasi ini, dan Panda mencakup fungsi dan metode yang membuat perselisihan data semacam ini cepat dan mudah

Di sini kita akan melihat rangkaian sederhana

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)
    
1 dan
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)
    
2s dengan fungsi
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)
    
5;

Kita mulai dengan impor standar

Dalam [1]

import pandas as pd
import numpy as np

Untuk kenyamanan, kami akan mendefinisikan fungsi ini yang membuat

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)
    
2 dari bentuk tertentu yang akan berguna di bawah

Di [2]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))

Keluar[2]

ABC0A0B0C01A1B1C12A2B2C2

Selain itu, kami akan membuat kelas cepat yang memungkinkan kami menampilkan beberapa

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)
    
2 secara berdampingan. Kode ini menggunakan metode
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)
    
_8 khusus, yang digunakan IPython untuk mengimplementasikan tampilan objeknya yang kaya

Dalam [3]

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)
    

Penggunaan ini akan menjadi lebih jelas saat kita melanjutkan diskusi kita di bagian berikut

Mengingat. Penggabungan NumPy Array

Penggabungan objek

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)
    
1 dan
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)
    
2 sangat mirip dengan penggabungan array Numpy, yang dapat dilakukan melalui fungsi
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
1 seperti yang dibahas dalam Dasar-dasar Array NumPy. Ingatlah bahwa dengan itu, Anda dapat menggabungkan konten dari dua atau lebih larik menjadi satu larik

Di [4]

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])

Keluar[4]

array([1, 2, 3, 4, 5, 6, 7, 8, 9])

Argumen pertama adalah daftar atau tupel array untuk digabungkan. Selain itu, dibutuhkan kata kunci

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
_2 yang memungkinkan Anda untuk menentukan sumbu di mana hasilnya akan digabungkan

Dalam [5]

x = [[1, 2],
     [3, 4]]
np.concatenate([x, x], axis=1)

Keluar[5]

array([[1, 2, 1, 2],
       [3, 4, 3, 4]])

Penggabungan sederhana dengan 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) 5

Panda memiliki fungsi,

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
_4, yang memiliki sintaks yang mirip dengan
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
1 tetapi berisi sejumlah opsi yang akan kita bahas sebentar lagi

# Signature in Pandas v0.18
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
4 dapat digunakan untuk penggabungan sederhana dari
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)
    
1 atau
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)
    
2 objek, sama seperti
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
9 dapat digunakan untuk penggabungan array sederhana

Di [6]

ser1 = pd.Series(['A', 'B', 'C'], index=[1, 2, 3])
ser2 = pd.Series(['D', 'E', 'F'], index=[4, 5, 6])
pd.concat([ser1, ser2])

Keluar[6]

1    A
2    B
3    C
4    D
5    E
6    F
dtype: object

Ini juga berfungsi untuk menggabungkan objek berdimensi lebih tinggi, seperti

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)
    
2s

Di [7]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
0

Keluar[7]

df1

AB1A1B12A2B2

df2

AB3A3B34A4B4

pd. concat([df1, df2])

AB1A1B12A2B23A3B34A4B4

Secara default, penggabungan terjadi secara berurutan dalam

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)
    
2 (i. e. ,
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
_2). Seperti
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
_1,
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)
    
5 memungkinkan spesifikasi sumbu di mana penggabungan akan dilakukan. Perhatikan contoh berikut

Di [8]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
1

Keluar[8]

df3

AB0A0B01A1B1

df4

CD0C0D01C1D1

pd. concat([df3, df4], axis='col')

ABCD0A0B0C0D01A1B1C1D1

Kita bisa saja menentukan

array([1, 2, 3, 4, 5, 6, 7, 8, 9])
5;

Indeks duplikat

Satu perbedaan penting antara

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
1 dan
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)
    
5 adalah bahwa penggabungan Panda mempertahankan indeks, meskipun hasilnya akan memiliki indeks duplikat. Pertimbangkan contoh sederhana ini

Dalam [9]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
2

Keluar[9]

x

AB0A0B01A1B1

y

AB0A2B21A3B3

pd. concat([x, y])

AB0A0B01A1B10A2B21A3B3

Perhatikan indeks berulang dalam hasilnya. Meskipun ini berlaku dalam

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)
    
_2s, hasilnya seringkali tidak diinginkan.
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
4 memberi kita beberapa cara untuk menanganinya

Menangkap pengulangan sebagai kesalahan

Jika Anda hanya ingin memverifikasi bahwa indeks dalam hasil

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
np.concatenate([x, y, z])
4 tidak tumpang tindih, Anda dapat menentukan bendera
x = [[1, 2],
     [3, 4]]
np.concatenate([x, x], axis=1)
2. Dengan disetel ke True, rangkaian akan memunculkan pengecualian jika ada indeks rangkap. Berikut adalah contoh, di mana untuk kejelasan kami akan menangkap dan mencetak pesan kesalahan

Di [10]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
3

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
4

Mengabaikan indeks

Terkadang indeks itu sendiri tidak penting, dan Anda lebih suka mengabaikannya begitu saja. Opsi ini dapat ditentukan menggunakan flag

x = [[1, 2],
     [3, 4]]
np.concatenate([x, x], axis=1)
3. Dengan disetel ke true, rangkaian akan membuat indeks bilangan bulat baru untuk
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)
    
1 yang dihasilkan

Di [11]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
5

Keluar[11]

x

AB0A0B01A1B1

y

AB0A2B21A3B3

pd. concat([x, y], abaikan_index=True)

AB0A0B01A1B12A2B23A3B3

Menambahkan kunci MultiIndex

Opsi lainnya adalah menggunakan opsi

x = [[1, 2],
     [3, 4]]
np.concatenate([x, x], axis=1)
_5 untuk menentukan label untuk sumber data;

Dalam [12]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
6

Keluar[12]

x

AB0A0B01A1B1

y

AB0A2B21A3B3

pd. concat([x, y], kunci=['x', 'y'])

ABx0A0B01A1B1y0A2B21A3B3

Hasilnya adalah pengindeksan ganda

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)
    
_2, dan kita dapat menggunakan alat yang dibahas dalam Pengindeksan Hierarkis untuk mengubah data ini menjadi representasi yang kita minati

Penggabungan dengan gabungan

Dalam contoh sederhana yang baru saja kita lihat, kita terutama menggabungkan

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)
    
2s dengan nama kolom bersama. Dalam praktiknya, data dari sumber yang berbeda mungkin memiliki kumpulan nama kolom yang berbeda, dan
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)
    
5 menawarkan beberapa opsi dalam kasus ini. Pertimbangkan gabungan dari dua
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)
    
2 berikut, yang memiliki beberapa (tetapi tidak semua. ) kolom yang sama

Di [13]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
7

Keluar[13]

df5

ABC1A1B1C12A2B2C2

df6

BCD3B3C3D34B4C4D4

pd. concat([df5, df6])

ABCD1A1B1C1NaN2A2B2C2NaN3NaNB3C3D34NaNB4C4D4

Secara default, entri yang datanya tidak tersedia diisi dengan nilai NA. Untuk mengubahnya, kita dapat menentukan salah satu dari beberapa opsi untuk parameter

array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
0 dan
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
1 dari fungsi concatenate. Secara default, gabungan adalah gabungan dari kolom input (
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
2), tetapi kita dapat mengubahnya menjadi perpotongan kolom menggunakan
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
3

Dalam [14]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
_8

Keluar[14]

df5

ABC1A1B1C12A2B2C2

df6

BCD3B3C3D34B4C4D4

pd. concat([df5, df6], bergabung='dalam')

BC1B1C12B2C23B3C34B4C4

Pilihan lain adalah dengan langsung menentukan indeks dari kolom yang tersisa menggunakan argumen

array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
1, yang mengambil daftar objek indeks. Di sini kami akan menentukan bahwa kolom yang dikembalikan harus sama dengan input pertama

Di [15]

def make_df(cols, ind):
    """Quickly make a DataFrame"""
    data = {c: [str(c) + str(i) for i in ind]
            for c in cols}
    return pd.DataFrame(data, ind)

# example DataFrame
make_df('ABC', range(3))
_9

Keluar[15]

df5

ABC1A1B1C12A2B2C2

df6

BCD3B3C3D34B4C4D4

pd. concat([df5, df6], join_axes=[df5. kolom])

ABC1A1B1C12A2B2C23NaNB3C34NaNB4C4

Kombinasi opsi fungsi

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)
    
5 memungkinkan berbagai kemungkinan perilaku saat menggabungkan dua kumpulan data;

Metode array([[1, 2, 1, 2], [3, 4, 3, 4]])_6

Karena penggabungan array langsung sangat umum, objek

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)
    
1 dan
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)
    
2 memiliki metode
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
9 yang dapat mencapai hal yang sama dengan penekanan tombol yang lebih sedikit. Misalnya, daripada menelepon
# Signature in Pandas v0.18
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)
_0, Anda cukup menelepon
# Signature in Pandas v0.18
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)
1

Dalam [16]

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

Keluar[16]

df1

AB1A1B12A2B2

df2

AB3A3B34A4B4

df1. tambahkan (df2)

AB1A1B12A2B23A3B34A4B4

Perlu diingat bahwa tidak seperti

array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
_6 dan
# Signature in Pandas v0.18
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)
3 metode daftar Python, metode
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
6 di Pandas tidak mengubah objek asli–melainkan membuat objek baru dengan data gabungan. Ini juga bukan metode yang sangat efisien, karena melibatkan pembuatan indeks baru dan buffer data. Jadi, jika Anda berencana untuk melakukan beberapa operasi
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
9, umumnya lebih baik membuat daftar
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)
    
2 dan meneruskan semuanya sekaligus ke fungsi
# Signature in Pandas v0.18
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)
7

Di bagian selanjutnya, kita akan melihat pendekatan lain yang lebih kuat untuk menggabungkan data dari berbagai sumber, penggabungan/penggabungan gaya database yang diterapkan di

# Signature in Pandas v0.18
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)
8. Untuk informasi lebih lanjut tentang
# Signature in Pandas v0.18
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)
_7,
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])
6, dan fungsionalitas terkait, lihat bagian "Gabung, Gabung, dan Gabungkan" dari dokumentasi Pandas

Bagaimana cara mencetak dua sisi hasil

side_by_side memungkinkan pengguna mencetak dua keluaran multi-baris secara berdampingan . Ini menghasilkan efek yang mirip dengan menjalankan diff -y file1 file2 di sistem Unix.

Bagaimana cara mencetak dua kolom keluaran?

Untuk mencetak dalam dua kolom. Pada pita, klik File. Mencetak. Penyiapan Halaman .

Bagaimana Anda mencetak kolom dengan Python?

3 Cara Mudah Mencetak Nama Kolom dengan Python .
Menggunakan panda. kerangka data. kolom untuk mencetak nama kolom dengan Python. .
Menggunakan panda. kerangka data. kolom. .
Metode Python sort() untuk mendapatkan nama kolom. Metode Python sort() dapat digunakan untuk mendapatkan daftar nama kolom dari kerangka data dalam urutan kolom yang menaik

Bagaimana Anda mencetak bersebelahan dengan Python?

print(i), (dengan koma) Harus melakukan pekerjaan.