Pandas学习

最新推荐文章于 2024-01-06 09:53:14 发布
最新推荐文章于 2024-01-06 09:53:14 发布
阅读量194 收藏 2
点赞数 1
分类专栏： Python 文章标签： Pandas
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44074488/article/details/101102524
版权
这篇博客深入介绍了Pandas，强调了它与Numpy的区别，详细讲解了Series和DataFrame数据结构，以及如何选择、设置数据。还涵盖了处理缺失数据的方法，重点讨论了Pandas的concat和merge功能，包括不同类型的合并方式和解决重叠问题。
摘要由CSDN通过智能技术生成

1. Pandas基本介绍

1.1 Numpy和Pandas有什么不同

如果用 python 的列表和字典来作比较, 那么可以说 Numpy 是列表形式的，没有数值标签，而 Pandas 就是字典形式。Pandas是基于Numpy构建的，让Numpy为中心的应用变得更加简单。

要使用pandas，首先需要了解他主要两个数据结构：Series和DataFrame。

1.2 Series
Series的字符串表现形式为：索引在左边，值在右边。由于我们没有为数据指定索引。于是会自动创建一个0到N-1（N为长度）的整数型索引。 
import pandas as pd
import numpy as np

s = pd.Series([1,3,6,np.nan,44,1])
print(s)
"""
0     1.0
1     3.0
2     6.0
3     NaN
4    44.0
5     1.0
dtype: float64
"""
1.3 DataFrame
DataFrame是一个表格型的数据结构，它包含有一组有序的列，每列可以是不同的值类型（数值，字符串，布尔值等）。DataFrame既有行索引也有列索引， 它可以被看做由Series组成的大字典。 
dates = pd.date_range('20160101',periods=6)
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['a','b','c','d'])
print(df)
"""
                   a         b         c         d
2016-01-01 -0.253065 -2.071051 -0.640515  0.613663
2016-01-02 -1.147178  1.532470  0.989255 -0.499761
2016-01-03  1.221656 -2.390171  1.862914  0.778070
2016-01-04  1.473877 -0.046419  0.610046  0.204672
2016-01-05 -1.584752 -0.700592  1.487264 -1.778293
2016-01-06  0.633675 -1.414157 -0.277066 -0.442545
"""

# 我们可以根据每一个不同的索引来挑选数据, 比如挑选 b 的元素:
print(df['b'])
"""
2016-01-01   -2.071051
2016-01-02    1.532470
2016-01-03   -2.390171
2016-01-04   -0.046419
2016-01-05   -0.700592
2016-01-06   -1.414157
Freq: D, Name: b, dtype: float64
"""

# 我们在创建一组没有给定行标签和列标签的数据 df1:
df1 = pd.DataFrame(np.arange(12).reshape((3,4)))
print(df1)
"""
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
"""

# 还有一种生成 df 的方法, 如下 df2:
df2 = pd.DataFrame({'A' : 1.,
                    'B' : pd.date_range('20160101', periods=4),
                    'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
                    'D' : np.array([3] * 4,dtype='int32'),
                    'E' : pd.Categorical(["test","train","test","train"]),
                    'F' : 'foo'})         
print(df2)
"""
     A          B    C  D      E    F
0  1.0 2016-01-01  1.0  3   test  foo
1  1.0 2016-01-02  1.0  3  train  foo
2  1.0 2016-01-03  1.0  3   test  foo
3  1.0 2016-01-04  1.0  3  train  foo
"""

# 如果想要查看数据中的类型, 我们可以用 dtype 这个属性:
print(df2.dtypes)
"""
df2.dtypes
A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object
"""

# 如果想看对行、列的序号:
print(df2.index)
# Int64Index([0, 1, 2, 3], dtype='int64')
print(df2.columns)
# Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')

# 如果只想看所有df2的值:
print(df2.values)
"""
[[1 Timestamp('2016-01-01 00:00:00') 1.0 3 'test' 'foo']
 [1 Timestamp('2016-01-02 00:00:00') 1.0 3 'train' 'foo']
 [1 Timestamp('2016-01-03 00:00:00') 1.0 3 'test' 'foo']
 [1 Timestamp('2016-01-04 00:00:00') 1.0 3 'train' 'foo']]
"""

# 想知道数据的总结, 可以用 describe():
print(df2.describe())
"""
         A    C    D
count  4.0  4.0  4.0
mean   1.0  1.0  3.0
std    0.0  0.0  0.0
min    1.0  1.0  3.0
25%    1.0  1.0  3.0
50%    1.0  1.0  3.0
75%    1.0  1.0  3.0
max    1.0  1.0  3.0
"""

# 如果想翻转数据, transpose:
print(df2.T)
"""                   
0                    1                    2  \
A                    1                    1                    1   
B  2013-01-02 00:00:00  2013-01-02 00:00:00  2013-01-02 00:00:00   
C                    1                    1                    1   
D                    3                    3                    3   
E                 test                train                 test   
F                  foo                  foo                  foo   

                     3  
A                    1  
B  2013-01-02 00:00:00  
C                    1  
D                    3  
E                train  
F                  foo  

"""

# 如果想对数据的 index 进行排序并输出:
print(df2.sort_index(axis=1, ascending=False))
"""
     F      E  D    C          B    A
0  foo   test  3  1.0 2016-01-01  1.0
1  foo  train  3  1.0 2016-01-02  1.0
2  foo   test  3  1.0 2016-01-03  1.0
3  foo  train  3  1.0 2016-01-04  1.0
"""

# 如果是对数据 值 排序输出:
print(df2.sort_values(by='B'))
"""
     A          B    C  D      E    F
0  1.0 2016-01-04  1.0  3   test  foo
1  1.0 2016-01-03  1.0  3  train  foo
2  1.0 2016-01-02  1.0  3   test  foo
3  1.0 2016-01-01  1.0  3  train  foo
"""

2. Pandas选择数据

2.1 简单的选择 
# 我们建立了一个 6X4 的矩阵数据。
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=['A','B','C','D'])
"""
             A   B   C   D
2013-01-01   0   1   2   3
2013-01-02   4   5   6   7
2013-01-03   8   9  10  11
2013-01-04  12  13  14  15
2013-01-05  16  17  18  19
2013-01-06  20  21  22  23
"""

# 简单筛选
print(df['A'])
print(df.A)

"""
2013-01-01     0
2013-01-02     4
2013-01-03     8
2013-01-04    12
2013-01-05    16
2013-01-06    20
Freq: D, Name: A, dtype: int64
"""

# 让选择跨越多行或多列:
print(df[0:3])
 
"""
            A  B   C   D
2013-01-01  0  1   2   3
2013-01-02  4  5   6   7
2013-01-03  8  9  10  11
"""

print(df['20130102':'20130104'])

"""
A   B   C   D
2013-01-02   4   5   6   7
2013-01-03   8   9  10  11
2013-01-04  12  13  14  15
"""
2.2 根据标签loc
同样我们可以使用标签来选择数据 loc, 本例子主要通过标签名字选择某一行数据， 或者通过选择某行或者所有行（:代表所有行）然后选其中某一列或几列数据。: 
print(df.loc['20130102'])
"""
A    4
B    5
C    6
D    7
Name: 2013-01-02 00:00:00, dtype: int64
"""

print(df.loc[:,['A','B']]) 
"""
             A   B
2013-01-01   0   1
2013-01-02   4   5
2013-01-03   8   9
2013-01-04  12  13
2013-01-05  16  17
2013-01-06  20  21
"""

print(df.loc['20130102',['A','B']])
"""
A    4
B    5
Name: 2013-01-02 00:00:00, dtype: int64
"""
2.3 根据序列iloc
另外我们可以采用位置进行选择 iloc, 在这里我们可以通过位置选择在不同情况下所需要的数据例如选某一个，连续选或者跨行选等操作。 
print(df.iloc[3,1])
# 13

print(df.iloc[3:5,1:3])
"""
             B   C
2013-01-04  13  14
2013-01-05  17  18
"""

print(df.iloc[[1,3,5],1:3])
"""
             B   C
2013-01-02   5   6
2013-01-04  13  14
2013-01-06  21  22
"""

# 当然我们可以采用混合选择 ix, 其中选择’A’和’C’的两列，并选择前三行的数据。
print(df.ix[:3,['A','C']])
"""
            A   C
2013-01-01  0   2
2013-01-02  4   6
2013-01-03  8  10
"""

# 最后我们可以采用判断指令进行选择
print(df[df.A>8])
"""
             A   B   C   D
2013-01-04  12  13  14  15
2013-01-05  16  17  18  19
2013-01-06  20  21  22  23
"""

3. Pandas设置值 

dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=['A','B','C','D'])

"""
             A   B   C   D
2013-01-01   0   1   2   3
2013-01-02   4   5   6   7
2013-01-03   8   9  10  11
2013-01-04  12  13  14  15
2013-01-05  16  17  18  19
2013-01-06  20  21  22  23
"""

# 根据位置设置loc和iloc
# 我们可以利用索引或者标签确定需要修改值的位置。
df.iloc[2,2] = 1111
df.loc['20130101','B'] = 2222

"""
             A     B     C   D
2013-01-01   0  2222     2   3
2013-01-02   4     5     6   7
2013-01-03   8     9  1111  11
2013-01-04  12    13    14  15
2013-01-05  16    17    18  19
2013-01-06  20    21    22  23
"""

# 根据条件设置
df.B[df.A>4] = 0
"""
             A     B     C   D
2013-01-01   0  2222     2   3
2013-01-02   4     5     6   7
2013-01-03   8     0  1111  11
2013-01-04  12     0    14  15
2013-01-05  16     0    18  19
"""

# 添加数据
df['E'] = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130101',periods=6))
"""
             A     B     C   D  E
2013-01-01   0  2222     2   3  1
2013-01-02   4     5     6   7  2
2013-01-03   8     0  1111  11  3
2013-01-04  12     0    14  15  4
2013-01-05  16     0    18  19  5
2013-01-06  20     0    22  23  6
"""

4. Pandas处理丢失数据 

# 创建含nan矩阵
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=['A','B','C','D'])
df.iloc[0,1] = np.nan
df.iloc[1,2] = np.nan
"""
             A     B     C   D
2013-01-01   0   NaN   2.0   3
2013-01-02   4   5.0   NaN   7
2013-01-03   8   9.0  10.0  11
2013-01-04  12  13.0  14.0  15
2013-01-05  16  17.0  18.0  19
2013-01-06  20  21.0  22.0  23
"""

# pd.dropna()
print(df.dropna(
    axis=0, # 0: 对行进行操作; 1: 对列进行操作
    how='any' # 'any': 只要存在 NaN 就 drop 掉; 'all': 必须全部是 NaN 才 drop 
))
"""
             A     B     C   D
2013-01-03   8   9.0  10.0  11
2013-01-04  12  13.0  14.0  15
2013-01-05  16  17.0  18.0  19
2013-01-06  20  21.0  22.0  23
"""

# pd.fillna()
print(df.fillna(value=0))
"""
             A     B     C   D
2013-01-01   0   0.0   2.0   3
2013-01-02   4   5.0   0.0   7
2013-01-03   8   9.0  10.0  11
2013-01-04  12  13.0  14.0  15
2013-01-05  16  17.0  18.0  19
2013-01-06  20  21.0  22.0  23
"""

# pd.isnull()
print(df.isnull())
"""
                A      B      C      D
2013-01-01  False   True  False  False
2013-01-02  False  False   True  False
2013-01-03  False  False  False  False
2013-01-04  False  False  False  False
2013-01-05  False  False  False  False
2013-01-06  False  False  False  False
"""

# 检测在数据中是否存在 NaN, 如果存在就返回 True:
print(np.any(df.isnull()))
# True

5. Pandas合并contact

5.1 axis(合并方向)
import pandas as pd
import numpy as np

#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*2, columns=['a','b','c','d'])

# concat纵向合并
res = pd.concat([df1, df2, df3], axis=0)

#打印结果
print(res)
#     a    b    c    d
# 0  0.0  0.0  0.0  0.0
# 1  0.0  0.0  0.0  0.0
# 2  0.0  0.0  0.0  0.0
# 0  1.0  1.0  1.0  1.0
# 1  1.0  1.0  1.0  1.0
# 2  1.0  1.0  1.0  1.0
# 0  2.0  2.0  2.0  2.0
# 1  2.0  2.0  2.0  2.0
# 2  2.0  2.0  2.0  2.0

# ignore_index (重置 index)
#承上一个例子，并将index_ignore设定为True
res = pd.concat([df1, df2, df3], axis=0, ignore_index=True)

#打印结果
print(res)
#     a    b    c    d
# 0  0.0  0.0  0.0  0.0
# 1  0.0  0.0  0.0  0.0
# 2  0.0  0.0  0.0  0.0
# 3  1.0  1.0  1.0  1.0
# 4  1.0  1.0  1.0  1.0
# 5  1.0  1.0  1.0  1.0
# 6  2.0  2.0  2.0  2.0
# 7  2.0  2.0  2.0  2.0
# 8  2.0  2.0  2.0  2.0
5.2 join (合并方式)
# join(合并方式)
# join='outer'为预设值，因此未设定任何参数时函数默认join='outer'。
# 此方式是依照column来做纵向合并，有相同的column上下合并在一起，
# 其他独自的column个自成列，原本没有值的位置皆以NaN填充。
import pandas as pd
import numpy as np

#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])

#纵向"外"合并df1与df2
res = pd.concat([df1, df2], axis=0, join='outer')

print(res)
#     a    b    c    d    e
# 1  0.0  0.0  0.0  0.0  NaN
# 2  0.0  0.0  0.0  0.0  NaN
# 3  0.0  0.0  0.0  0.0  NaN
# 2  NaN  1.0  1.0  1.0  1.0
# 3  NaN  1.0  1.0  1.0  1.0
# 4  NaN  1.0  1.0  1.0  1.0

#承上一个例子

#纵向"内"合并df1与df2
res = pd.concat([df1, df2], axis=0, join='inner')

#打印结果
print(res)
#     b    c    d
# 1  0.0  0.0  0.0
# 2  0.0  0.0  0.0
# 3  0.0  0.0  0.0
# 2  1.0  1.0  1.0
# 3  1.0  1.0  1.0
# 4  1.0  1.0  1.0

#重置index并打印结果
res = pd.concat([df1, df2], axis=0, join='inner', ignore_index=True)
print(res)
#     b    c    d
# 0  0.0  0.0  0.0
# 1  0.0  0.0  0.0
# 2  0.0  0.0  0.0
# 3  1.0  1.0  1.0
# 4  1.0  1.0  1.0
# 5  1.0  1.0  1.0
5.3 join_axes(依照axes合并)
import pandas as pd
import numpy as np

#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])

#依照`df1.index`进行横向合并
res = pd.concat([df1, df2], axis=1, join_axes=[df1.index])

#打印结果
print(res)
#     a    b    c    d    b    c    d    e
# 1  0.0  0.0  0.0  0.0  NaN  NaN  NaN  NaN
# 2  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0
# 3  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0

#移除join_axes，并打印结果
res = pd.concat([df1, df2], axis=1)
print(res)
#     a    b    c    d    b    c    d    e
# 1  0.0  0.0  0.0  0.0  NaN  NaN  NaN  NaN
# 2  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0
# 3  0.0  0.0  0.0  0.0  1.0  1.0  1.0  1.0
# 4  NaN  NaN  NaN  NaN  1.0  1.0  1.0  1.0
5.4 join_axes(依照axes合并)
# append只有纵向合并，没有横向合并。
import pandas as pd
import numpy as np

#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
s1 = pd.Series([1,2,3,4], index=['a','b','c','d'])

#将df2合并到df1的下面，以及重置index，并打印出结果
res = df1.append(df2, ignore_index=True)
print(res)
#     a    b    c    d
# 0  0.0  0.0  0.0  0.0
# 1  0.0  0.0  0.0  0.0
# 2  0.0  0.0  0.0  0.0
# 3  1.0  1.0  1.0  1.0
# 4  1.0  1.0  1.0  1.0
# 5  1.0  1.0  1.0  1.0

#合并多个df，将df2与df3合并至df1的下面，以及重置index，并打印出结果
res = df1.append([df2, df3], ignore_index=True)
print(res)
#     a    b    c    d
# 0  0.0  0.0  0.0  0.0
# 1  0.0  0.0  0.0  0.0
# 2  0.0  0.0  0.0  0.0
# 3  1.0  1.0  1.0  1.0
# 4  1.0  1.0  1.0  1.0
# 5  1.0  1.0  1.0  1.0
# 6  1.0  1.0  1.0  1.0
# 7  1.0  1.0  1.0  1.0
# 8  1.0  1.0  1.0  1.0

#合并series，将s1合并至df1，以及重置index，并打印出结果
res = df1.append(s1, ignore_index=True)
print(res)
#     a    b    c    d
# 0  0.0  0.0  0.0  0.0
# 1  0.0  0.0  0.0  0.0
# 2  0.0  0.0  0.0  0.0
# 3  1.0  2.0  3.0  4.0

6. Pandas合并merge

6.1 依据一组key合并
import pandas as pd

#定义资料集并打印出
left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                             'A': ['A0', 'A1', 'A2', 'A3'],
                             'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                              'C': ['C0', 'C1', 'C2', 'C3'],
                              'D': ['D0', 'D1', 'D2', 'D3']})

print(left)
#    A   B key
# 0  A0  B0  K0
# 1  A1  B1  K1
# 2  A2  B2  K2
# 3  A3  B3  K3

print(right)
#    C   D key
# 0  C0  D0  K0
# 1  C1  D1  K1
# 2  C2  D2  K2
# 3  C3  D3  K3

#依据key column合并，并打印出
res = pd.merge(left, right, on='key')

print(res)
     A   B key   C   D
# 0  A0  B0  K0  C0  D0
# 1  A1  B1  K1  C1  D1
# 2  A2  B2  K2  C2  D2
# 3  A3  B3  K3  C3  D3
6.2 依据两组key合并
import pandas as pd

#定义资料集并打印出
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                      'key2': ['K0', 'K1', 'K0', 'K1'],
                      'A': ['A0', 'A1', 'A2', 'A3'],
                      'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                       'key2': ['K0', 'K0', 'K0', 'K0'],
                       'C': ['C0', 'C1', 'C2', 'C3'],
                       'D': ['D0', 'D1', 'D2', 'D3']})

print(left)
#    A   B key1 key2
# 0  A0  B0   K0   K0
# 1  A1  B1   K0   K1
# 2  A2  B2   K1   K0
# 3  A3  B3   K2   K1

print(right)
#    C   D key1 key2
# 0  C0  D0   K0   K0
# 1  C1  D1   K1   K0
# 2  C2  D2   K1   K0
# 3  C3  D3   K2   K0

#依据key1与key2 columns进行合并，并打印出四种结果['left', 'right', 'outer', 'inner']
res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
print(res)
#    A   B key1 key2   C   D
# 0  A0  B0   K0   K0  C0  D0
# 1  A2  B2   K1   K0  C1  D1
# 2  A2  B2   K1   K0  C2  D2

res = pd.merge(left, right, on=['key1', 'key2'], how='outer')
print(res)
#     A    B key1 key2    C    D
# 0   A0   B0   K0   K0   C0   D0
# 1   A1   B1   K0   K1  NaN  NaN
# 2   A2   B2   K1   K0   C1   D1
# 3   A2   B2   K1   K0   C2   D2
# 4   A3   B3   K2   K1  NaN  NaN
# 5  NaN  NaN   K2   K0   C3   D3

res = pd.merge(left, right, on=['key1', 'key2'], how='left')
print(res)
#    A   B key1 key2    C    D
# 0  A0  B0   K0   K0   C0   D0
# 1  A1  B1   K0   K1  NaN  NaN
# 2  A2  B2   K1   K0   C1   D1
# 3  A2  B2   K1   K0   C2   D2
# 4  A3  B3   K2   K1  NaN  NaN

res = pd.merge(left, right, on=['key1', 'key2'], how='right')
print(res)
#     A    B key1 key2   C   D
# 0   A0   B0   K0   K0  C0  D0
# 1   A2   B2   K1   K0  C1  D1
# 2   A2   B2   K1   K0  C2  D2
# 3  NaN  NaN   K2   K0  C3  D3
6.3 Indicator
import pandas as pd

#定义资料集并打印出
df1 = pd.DataFrame({'col1':[0,1], 'col_left':['a','b']})
df2 = pd.DataFrame({'col1':[1,2,2],'col_right':[2,2,2]})

print(df1)
#   col1 col_left
# 0     0        a
# 1     1        b

print(df2)
#   col1  col_right
# 0     1          2
# 1     2          2
# 2     2          2

# 依据col1进行合并，并启用indicator=True，最后打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)
print(res)
#   col1 col_left  col_right      _merge
# 0   0.0        a        NaN   left_only
# 1   1.0        b        2.0        both
# 2   2.0      NaN        2.0  right_only
# 3   2.0      NaN        2.0  right_only

# 自定indicator column的名称，并打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
print(res)
#   col1 col_left  col_right indicator_column
# 0   0.0        a        NaN        left_only
# 1   1.0        b        2.0             both
# 2   2.0      NaN        2.0       right_only
# 3   2.0      NaN        2.0       right_only
6.4 依据index合并
import pandas as pd

#定义资料集并打印出
left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                     'B': ['B0', 'B1', 'B2']},
                     index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                      'D': ['D0', 'D2', 'D3']},
                     index=['K0', 'K2', 'K3'])

print(left)
#     A   B
# K0  A0  B0
# K1  A1  B1
# K2  A2  B2

print(right)
#     C   D
# K0  C0  D0
# K2  C2  D2
# K3  C3  D3

#依据左右资料集的index进行合并，how='outer',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
print(res)
#      A    B    C    D
# K0   A0   B0   C0   D0
# K1   A1   B1  NaN  NaN
# K2   A2   B2   C2   D2
# K3  NaN  NaN   C3   D3

#依据左右资料集的index进行合并，how='inner',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='inner')
print(res)
#     A   B   C   D
# K0  A0  B0  C0  D0
# K2  A2  B2  C2  D2
6.5 解决overlapping的问题
import pandas as pd

#定义资料集
boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})

#使用suffixes解决overlapping的问题
res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')
print(res)
#    age_boy   k  age_girl
# 0        1  K0         4
# 1        1  K0         5
ZonePG
关注
专栏目录
Pandas 学习笔记基础知识汇总
marvinmao的博客
08-02 4773
一、pandas读取和存储excel、csv文件 1、df1 = pd.read_excel( file_path ,index_col = ‘col2’ ) 设置索引列为col2，读取出来的数据是dataframe格式 2、df2 = pd.read_csv( serprator =’::’,engine = python) 设置分隔符和读取引擎 3、dataframe.to_excel( file_path ) dataframe.to_csv( ) 4、pd.read_excel(filepath,
pandas学习资料
07-09
**Pandas学习资料详解** Pandas是Python编程语言中用于数据处理和分析的重要库，它提供了高效的数据结构，如DataFrame和Series，使得数据清洗、转换、统计分析等工作变得轻松便捷。以下将根据提供的文件名，解析出...
pandas学习
思维缜密的博客
07-07 2534
excel 单个sheet 不写sheet_name默认读第一个 多个sheet 写入 csv excel 单个sheet sheet_name不写默认Sheet1 多个sheet if_sheet_exists表示已经存在这个sheet之后的行为，有四种 插入/修改一行 插入末尾 不是每一列都要填数据 插入任意行 比如第k行 (不是每一列都要填数据) 修改一行 修改单元格 求平均 行 如果要添加进取的话 列 暂时没用到，再说把......
Pandas 学习
ZgaoYi的博客
08-10 715
Pandas 学习
pandas学习-01下载
qq_37590979的博客
01-06 1606
这里用的是pycharm的环境所以可以在pycharm的terminal进行包的安装。今天遇到了一些做表的问题,因为比较懒所以打算学习下pandas。然后就是一堆遇到的一堆新人问题,这里记录一下和相关的解决方法。这样目前的坑先踩到这里.
Pandas学习总结
weixin_52527244的博客
05-30 5110
介绍 Pandas 是非常著名的开源数据处理库，我们可以通过它完成对数据集进行快速读取、转换、过滤、分析等一系列操作。除此之外，Pandas 拥有强大的缺失数据处理与数据透视功能，可谓是数据预处理中的必备利器。 知识点 数据类型 数据读取 数据选择 数据删减 数据填充 数据类型 Pandas 的数据类型主要有以下几种，它们分别是：Series（一维数组），DataFrame（二维数组），Panel（三维数组），Panel4D（四维数组），PanelND（更多维数组）。其中 Series 和
pandas学习心得
zyf2695421695的博客
07-02 4408
Pandas是基于Numpy的专业数据分析工具，可以灵活高效地处理各种数据集，包含两种类型的数据结构：DataFrame（表）和Series（列） 。 pandas：字典+列表 df = pd.DataFrame({'姓名':['张三','李四'],'年龄':['11','22']},index = ['分类1','分类2']) 可以通过改变columns,index和values的值来控制数据。不指定索引时，从0开始的数字索引。 1.内容预览：df.head() 默认前5行 df.tail(...
pandas学习笔记之Series
m0_73721001的博客
10-28 2820
如代码所示，可以直接对Series结构进行加减乘除运算符，当出现index不匹配的情况时会输出NaN。类似list，通过append方法能够在原Series上插入（追加）新的Series。若只在原Series上插入单个值，则采用赋值方式即可。数据切片的概念源于Numpy数组，Series对象使用类似NumPy中ndarray的数据访问方法实现切片操作。可以直接通过赋值的方法修改Series中的对应值。nunique()返回去重后的元素个数。unique()返回去重后的元素值。如果 data 是标量值，则。
pandas学习笔记
phily123的博客
09-18 6347
一、访问某列 df[‘video_frame’] 二、添加一列 df[‘game_play’] 三、drop_duplicates() 添加链接描述 作用： 去除重复项。 用法： DataFrame.drop_duplicates(subset=None, keep=‘first’, inplace=False) 参数： subset : column label or sequence of labels, optional 用来指定特定的列，默认所有列 keep : {‘first’, ‘last’,
Pandas库学习
Lilo_的博客
07-14 1984
一、Pandas是什么 Pandas 是 Python 语言的一个扩展程序库，用于数据分析。 Pandas 一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算）。 Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据。 Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。 二、Pandas 的安装和使用 pip install pandas # 通过pip命令安装 import pand
Pandas学习（完成文件写入、追加写入、读取操作）
小金的博客
08-21 1599
我要对我的很多设备进行快照处理，打完快照之后需要记录我的设备IP和快照时间。当我们解决了需求的其他内容，只剩记录信息的时候，可以怎么做呢？
Pandas学习笔记整理.pdf
03-06
Pandas是一个强大的Python数据分析库，它提供了高性能、易用的数据结构和数据分析工具。基于Numpy构建，Pandas提供了两个主要的数据结构：Series和DataFrame。Series是一维标签数组，能够保存任何数据类型（整数、...
【pandas学习笔记(一)】pandas基本使用
12-21
【pandas学习笔记(一)】pandas基本使用 pandas是Python中广泛使用的数据分析库，它基于NumPy构建，提供了高效的数据结构，如Series（一维数组）和DataFrame（二维表格型数据结构）。pandas的主要功能是进行数据清洗...
电信客户流失数据，用于pandas学习
01-07
Pandas是一个在Python中广泛使用的数据分析库，因此描述中提到的“用于pandas学习”表明我们将用Pandas来处理和分析这个数据集。 首先，让我们深入了解一下Pandas。Pandas是Python编程语言中的一个开源库，它提供了...
中国移动：算网一体定义算力网络未来.pdf
最新发布
11-03
中国移动：算网一体定义算力网络未来.pdf
yolo算法-包装盒检测数据集-26张图像带标签-盒子.zip
11-03
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，包含数据集配置文件data.yaml，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
VB程序实例-使用Access报表.zip
11-03
VB程序实例-使用Access报表.zip
基于MATLAB图像平滑处理系统GUI面板.zip
11-03
强网杯
python pandas学习
08-09
Python pandas学习可以涉及以下内容： 1. 数据结构简介：DataFrame和Series，它们是pandas中最重要的两种数据结构。 2. 数据索引index，了解如何对数据进行索引，以便快速查找和筛选数据。 3. 利用pandas查询数据，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值