python的Datafram使用总结

python的Datafram使用总结

常用的一些方法总结


文章目录


一、datafram创建

1 、使用list创建

df1=pd.DataFrame({
        'name':['a','b','c'],
        'age':[20,21,22]
    })
print(df1)
   age name
0   20    a
1   21    b
2   22    c

df2=pd.DataFrame({
        'one':np.random.rand(3),
        'two':np.random.rand(3)
    },index=list('abc'))
print(df2)
        one       two
a  0.154260  0.372618
b  0.544828  0.497320
c  0.811307  0.071709
# 字典的key就是df的columns
# 字典的value是df的valuse
# 字典的长度需要保持一致

f2=pd.DataFrame({
        'one':np.random.rand(3),
        'two':np.random.rand(3)
    },index=list('abc'),columns=['two','three','one'])
print(df2)
# columns 可以重新排序,若不存在则填充为NaN
        two three       one
a  0.593346   NaN  0.772806
b  0.556199   NaN  0.025852
c  0.705040   NaN  0.173555

2 、使用Series创建

df1=pd.DataFrame({
        'one':pd.Series(np.random.rand(3)),
        'two':pd.Series(np.random.rand(3))
    })
print(df1)
        one       two
0  0.414850  0.665624
1  0.249675  0.699969
2  0.702770  0.900113
# 字典的key为df的columns,df的index为Series的index
# Series的长度可以不一样,会产生NaN

3 、通过二位数组直接创建

df1 = pd.DataFrame(np.arange(9).reshape((3,3)),
      index=list('abc'),
      columns=list('xyz'))
print(df1)
   x  y  z
a  0  1  2
b  3  4  5
c  6  7  8

4 、使用字典

# DataFrame 字典组成的列表
df1=pd.DataFrame([
        {'one':'a','two':'b'},
        {'three':'c','four':'d'}
    ],index=list('ab'))
print(df1)
# index不指定则为默认,
# 字典的key为df的columns,
    four  one   three   two
a   NaN    a     NaN     b
b    d    NaN     c     NaN

# 由字典组成的字典创建
df=pd.DataFrame({
        'A':{'math':80,'art':90},
         'B':{'math':80,'art':90}    
    })
print(df)
# df的columns为字典的key,df的index为子字典的key
       A   B
art   90  90
math  80  80

5 、创建空datafram

df =  pd.DataFrame(columns=['A', 'B', 'C']) 

二、获取datafram的基本信息

1 、获得行索引信息

df.index

2 、获得列索引信息

df.columns

3 、获得df的size

df.shape

4 、获得df的行数

df.shape[0]

5 、获得df的列数

df.shape[1]

6 、获得df中的值

df.values

7 、获得df中的头部

df.head()
df.head(10)   显示datafram的前十行

8 、获得df中的尾部

df.tail()

9 、获取列名列表

df.columns.values.tolist()

三、根据索引查找datafram信息

1 、选择列

# 选择单列,输出Series
data1=df['a']
# 选择多列,使用二维数据,输出DataFrame
data2=df[['a','c','d']]

2 、选择行

loc只能通过index和columns来取,不能用数字

df.loc['one','a']	#one行,a列
df.loc['one':'two','a']	#one到two行,a列
df.loc['one':'two','a':'c']	#one到two行,a到c列
df.loc['one':'two',['a','c']]	#one到two行,ac列

# 选择单行,输出Series
data1=df.loc['one']
# 选择多行,使用二维数据,输出DataFrame
data2=df.loc[['one','three']]  #二维数据

iloc只能用数字索引,不能用索引名

df.iloc[0:2]	#前2行
df.iloc[0]	#第0行
df.iloc[0:2,0:2]	#0、1行,0、1列
df.iloc[[0,2],[1,2,3]]	#第0、2行,1、2、3列

# 选择第一行
df.iloc[0]
# 选择倒数第一行
df.iloc[-1]
#选择第一和第三行
df.iloc[[0,2]]

其他

 
#iat取某个单值,只能数字索引
df.iat[1,1]#第1行,1列
#at取某个单值,只能index和columns索引
df.at['one','a']#one行,a列

3、同时选择行和列

#  选择one列的ac行
df['one'].loc[['a','c']]
# 选择two three four 的ac行
df[['two','three','four']].loc[['a','c']]
#或者 
df.iloc[i]['A']
df.iloc[:,[0]]#取第0列所有行,多取几列格式为 data.iloc[:,[0,1]] 
df.iloc[[0,1],[0,1]] #提取第0、1行,第0、1列中的数据
df.iloc[:,:] #取第0,1,2,3列的所有行
df.loc[:,['A']] #取'A'列所有行,多取几列格式为 data.loc[:,['A','B']]
df.loc[['a','b'],['A','B']] #提取index为'a','b',列名为'A','B'中的数据
df.loc[:,:] #取A,B,C,D列的所有行

4、获取满足某条件的行、元素所在的索引

_temp = {'job':['farmer', 'teacher', 'worker', 'acter', 'present'], 'money':[3000, 7000, 5000, 100000, 66666]}
df = pd.DataFrame(_temp)

        job   money
0   farmer    3000
1  teacher    7000
2   worker    5000
3    acter  100000
4  present   66666

a = df[(df['money']>10000)].index.tolist()
print(a)

[3, 4]

5、按条件取行

#选取等于某些值的行记录 用 ==
df.loc[df[‘column_name’] == some_value]
 
#选取某列是否是某一类型的数值 用 isin
df.loc[df[‘column_name’].isin(some_values)]
 
#多种条件的选取 用 &
df.loc[(df[‘column’] == some_value) & df[‘other_column’].isin(some_values)]
 
#选取不等于某些值的行记录 用 !=
df.loc[df[‘column_name’] != some_value]
 
#isin返回一系列的数值,如果要选择不符合这个条件的数值使用~
df.loc[~df[‘column_name’].isin(some_values)] 

#返回值满足,{A列含有数值[4,8]}
data[data['A'].isin([4,8])] 

 #逆函数 剔除{A列含有数值[4,8]}的dataframe
data[~data['A'].isin([4,8])]

四、datafram的设置

1 、设置某一列为dataframe的index

df = df.set_index('job')

2 、数据超过总宽度后,是否折叠显示

pd.set_option('expand_frame_repr', False) 

3 、数据显示总宽度

pd.set_option('display.width', 100) 

4 、显示最多行数,超出该数以省略号表示

pd.set_option('max_rows', 100)

5、显示最多列数,超出该数以省略号表示

pd.set_option('max_columns', 100)

6、数据超过设置显示最大行列数时,带省略号显示/若是info则是统计信息显示

pd.set_option('large_repr', 'truncate')

7、设置单列的宽度,用字符个数表示,单个数据长度超出该数时以省略号表示

pd.set_option('max_colwidth', 16) 

五、判断datafram符合条件

1 、datafram判断大小,会返回布尔值的datafram

df=pd.DataFrame(np.random.rand(12).reshape((3,4))*100)
print(df)
           0          1          2          3
0  29.892506  58.911433   8.225744  82.950538
1   0.025366  38.071510  63.716461  48.258320
2  45.380903  70.560190  30.495624   4.703547

print(df>50)
       0      1      2      3
0  False   True  False   True
1  False  False   True  False
2  False   True  False  False

2、显示符合条件的数值

print(df[df>50])
    0          1          2          3
0 NaN  58.911433        NaN  82.950538
1 NaN        NaN  63.716461        NaN
2 NaN  70.560190        NaN        NaN

六、datafram的增删改

1、datafram的增

# 增加新的一列,并全部赋值为300
df['e']=300

2、datafram的合并对齐

df1=pd.DataFrame(np.random.randn(10,4),columns=['a','b','c','d'])
df2=pd.DataFrame(np.random.randn(7,3),columns=['a','b','c'])
print(df1+df2)
# DataFrame 会自动根据列标签对其数据,没有的补NaN
          a         b         c   d
0 -0.118693 -0.587134  1.240605 NaN
1 -0.439958  2.960476 -0.728936 NaN
2  0.855115 -0.659808  1.018583 NaN
3 -3.006156  0.376281  0.559385 NaN
4 -2.946353  0.428331 -1.788409 NaN
5  0.820590 -1.077892 -0.506990 NaN
6 -0.628339  0.215887 -2.513543 NaN
7       NaN       NaN       NaN NaN
8       NaN       NaN       NaN NaN
9       NaN       NaN       NaN NaN

3、datafram的删

修改原数据

# 删除列
del df['a']

DataFrame.drop
DataFrame.drop(labels=None,axis=0, index=None, columns=None, inplace=False)
参数说明:
labels:就是要删除的行列的名字,用列表给定
axis: 默认为0,指删除行,因此删除columns时要指定axis=1;
index: 直接指定要删除的行
columns: 直接指定要删除的列
inplace=False:默认该删除操作不改变原数据,而是返回一个执行删除操作后的新dataframe;
inplace=True:则会直接在原数据上进行删除操作,删除后无法返回。

不修改原数据,生成新数列

# 删除行或列 
df1 = df.drop(0))
df.drop([0, 1])
df.drop(index=[0, 1])
# 如果使用drop删除列的话 必须用axis
df.drop(['b'],axis=1)   
df.drop(columns=['B', 'C'])

删除指定行:

df = {'DataBase':['mysql','test','test','test','test'],'table':['user','student','course','sc','book']}
df = pd.DataFrame(df)
  DataBase    table
0    mysql     user
1     test  student
2     test   course
3     test       sc
4     test     book
 
#删除table值为sc的那一行
df.drop(index=(df.loc[(df['table']=='sc')].index))              
  DataBase    table
0    mysql     user
1     test  student
2     test   course
4     test     book

3、datafram的改

1、整行整列修改
# 修改整列
df['d']=100

# 修改整行
df.loc[2]=200
2、按条件修改
#创建一个datafram
df=pd.DataFrame({"A":[1,2,3,4],"B":[5,6,7,8],"C":[1,1,1,1]})
   A  B  C
0  1  5  1
1  2  6  1
2  3  7  1
3  4  8  1

ix函数(df.ix[条件,操作区域]),可以用数字索引,也可以用index和column索引

df.ix[0]	#取第0行
df.ix[0:1]	#取第0行
df.ix['one':'two']	#取one、two行
df.ix[0:2,0]	#取第0、1行,第0列
df.ix[0:1,'a']	#取第0行,a列
df.ix[0:2,'a':'c']	#取第0、1行,abc列
df.ix['one':'two','a':'c']	#取one、two行,abc列
df.ix[0:2,0:1]	#取第0、1行,第0列
df.ix[0:2,0:2]	#取第0、1行,第0、1列

条件筛选

df.ix[df.A>1,'B']=-1
df
   A  B  C
0  1  5  1
1  2 -1  1
2  3 -1  1
3  4 -1  1

iterrows(): 按行遍历,将DataFrame的每一行迭代为(index, Series)对,可以通过row[name]对元素进行访问。
itertuples(): 按行遍历,将DataFrame的每一行迭代为元组,可以通过row[name]对元素进行访问,比iterrows()效率高。
iteritems():按列遍历,将DataFrame的每一列迭代为(列名, Series)对,可以通过row[index]对元素进行访问。

for index, row in df.iterrows():
    print(index) # 输出每行的索引值
	print( row) # 输出每行

for row in df.itertuples():
    print(getattr(row, 'c1'), getattr(row, 'c2')) # 输出每一行

for index, row in df.iteritems():
    print(index) # 输出列名

for row in df.iteritems():
    print(row[0], row[1], row[2]) # 输出各列对应的值

#iterrows()返回行和列
for index,row in df.iterrows():
	if row['A']>1:
		row['B']=-1
   A  B  C
0  1  5  1
1  2 -1  1
2  3 -1  1
3  4 -1  1

# where函数,np.where(条件,then,else)
df["then"]=np.where(df.A<3,1,0)
df
   A  B  C  then
0  1  5  1     1
1  2  6  1     1
2  3  7  1     0
3  4  8  1     0

#apply函数你可以对行或列每一个数值进行自己指定函数的操作
def judgeLevel(df):
    if df['A'] < 2:
        return 'C'
    elif df['A'] > 3:
        return 'A'
    else:
        return 'B'

 df['level']=df.apply(lambda r:judgeLevel(r),axis=1)
 df
   A  B  C   level
0  1  5  1    C
1  2  6  1    B
2  3  7  1    B
3  4  8  1    A

#map函数,列的每个元素都平方
 df['A']=df['A'].map(lambda x:x**2)

七、datafram的排序

1、按值排序

df.sort_values(['a'])
df.sort_values(['b'],ascending=False)
# ascending =True 为升序,false为降序
# 默认为升序

# 多列排序
df = df.sort_values(['a','b'])
# 先排a,如果a有重复,则排b

#按索引排序
df.sort_index()

八、datafram的其他操作

1、datafram的转置

df.T

2、缺失值处理

在这里插入图片描述

3、datafram的保存和读取

df.to_csv 写入到 csv 文件
pd.read_csv 读取 csv 文件
df.to_json 写入到 json 文件
pd.read_json 读取 json 文件
df.to_html 写入到 html 文件
pd.read_html 读取 html 文件
df.to_excel 写入到 excel 文件
pd.read_excel 读取 excel 文件

常见的:

DataFrame.to_csv(path_or_buf=None, sep=', ', na_rep='', float_format=None, 
columns=None, header=True, index=True,index_label=None, mode='w', encoding=None, 
compression=None, quoting=None, quotechar='"',line_terminator='\n', chunksize=None, 
tupleize_cols=None,date_format=None, doublequote=True,escapechar=None, decimal='.')

参数:
path_or_buf : 文件路径,如果没有指定则将会直接返回字符串的 json
sep : 输出文件的字段分隔符,默认为 “,”
na_rep : 用于替换空数据的字符串,默认为’’
float_format : 设置浮点数的格式(几位小数点)
columns : 要写的列
header : 是否保存列名,默认为 True ,保存
index : 是否保存索引,默认为 True ,保存
index_label : 索引的列标签名

4、去重

df = pd.DataFrame({'colA' : list('AABCA'), 'colB' : list('AABDA'),'colC' : [100,100,30,50,20], 'colD': [100,100,60,80,50]})

  colA colB  colC  colD
0    A    A   100   100
1    A    A   100   100
2    B    B    30    60
3    C    D    50    80
4    A    A    20    50

# 按全量字段去重, 保留第一个(默认)
df2 = df.drop_duplicates()

  colA colB  colC  colD
0    A    A   100   100
2    B    B    30    60
3    C    D    50    80
4    A    A    20    50

# 按指定字段去重, 保留第一个
df3 = df.drop_duplicates(subset=['colA', 'colB'], keep='first')

  colA colB  colC  colD
0    A    A   100   100
2    B    B    30    60
3    C    D    50    80

# 按全量字段去重, 保留最后一个
df3 = df.drop_duplicates(keep='last')

  colA colB  colC  colD
1    A    A   100   100
2    B    B    30    60
3    C    D    50    80
4    A    A    20    50


5、根据列拼接merge

merge是按照两个dataframe共有的column进行连接,两个dataframe必须具有同名的column

DataFrame.merge(self, right, how='inner', on=None, left_on=None, right_on=None,
                left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'),
                copy=True, indicator=False, validate=None)

right : DataFrame或命名的Series ,合并的对象。

how : {‘left’, ‘right’, ‘outer’, ‘inner’}, default ‘inner’ 默认为合并两个frame的交集

Type of merge to be performed. 合并类型。

left: 仅使用左frame中的键,类似于SQL左外部联接;保留关键顺序
right: 仅使用右frame中的键,类似于SQL右外部联接;保留关键顺序。
outer: 使用两个frame中键的并集,类似于SQL完全外部联接;按字典顺序对键进行排序。
inner: 使用两个frame中关键点的交集,类似于SQL内部联接;保留左键的顺序。

on : label or list
列名或索引 ,必须在两个DataFrame中都能找到。如果on为None且未用 索引 合并,则默认为两个DataFrame中列的交集

left_on : label or list, or array-like
左DataFrame中的列名或索引。也可以是左DataFrame长度的数组或数组列表。

right_on : label or list, or array-like
右DataFrame中的列名或索引。也可以是右DataFrame长度的数组或数组列表。

left_index : bool, default False
左DataFrame的索引作为连接键

right_index : bool, default False
右DataFrame的索引作为连接键

sort : bool, default False
在结果DataFrame中按字典顺序对连接键排序。如果为False,联接键的顺序取决于联接类型(how关键字)。

copy : bool, default True
默认为True, 总是将数据复制到数据结构中。设为Fasle,尽可能避免复制。

how=‘left’ ,仅使用左 frame 中的键,例子中 age=39 的行,左右 frame 的 class 值不同,class 属性使用左 frame 的键值,同时右 frame 的 Income 在左 frame 没有所以显示NaN值。就是让df1保留所有的行列数据,df2根据df1的行列进行补全

result = pd.merge(left, right, how='left', on=None, left_on=None, right_on=None,
                  left_index=False, right_index=False)

[外链图片转存失败,源站可能有防盗在这里插入!链机制,建描述]议将图片上https://传(imblog.csdnimg.cn/85TQZP6a38e8904b23a13c49054ab919.png7(https://img-blog.的csdnimg.cn/85bf6a38e8904b23a137330c114ab969.png)]
how=‘right’ ,仅使用右 frame 中的键,例子中 age=39 的行,左右 frame 的 class 值不同,class 属性使用右 frame 的键值,同时左 frame 的 Gender 和 Ed 在右 frame 没有所以显示NaN值。

result = pd.merge(left, right, how='right', on=None, left_on=None, right_on=None,
                  left_index=False, right_index=False)

在这里插入图片描述

how=‘inner’, 使用两个frame中键的交集。默认值。

result = pd.merge(left, right, how='inner', on=None, left_on=None, 
                  right_on=None, left_index=False, right_index=False)

在这里插入图片描述
how=‘outer’ ,使用两个frame中关键点的并集。

result = pd.merge(left, right, how='outer', on=None, left_on=None, right_on=None,
                  left_index=False, right_index=False)

在这里插入图片描述
on=‘Age’ , 与 how 选择模式无关。on所选列名必须为左右 frame 相同列。

result = pd.merge(left, right, how='inner', on='Age', left_on=None, right_on=None,
                  left_index=False, right_index=False)

在这里插入图片描述
on=‘Class’ , 与 how 选择模式无关,on所选列名必须为左右 frame 相同列。

result = pd.merge(left, right, how='inner', on='Class', left_on=None, right_on=None,
                  left_index=False, right_index=False)

在这里插入图片描述
“on” 和 “left_on” and “right_on”, 不能同时使用

6、concat合并DataFram

a = pd.DataFrame([[1, 2, 3],[4, 5, 6]], index=['index1', 'index2'], columns=['clo1', 'col2', 'col3'])

        clo1  col2  col3
index1     1     2     3
index2     4     5     6

b = pd.DataFrame([['a', 'b', 'c'],['d', 'e', 'f']], index=['index3', 'index4'], columns=['clo1', 'col2', 'col3'])

       clo1 col2 col3
index3    a    b    c
index4    d    e    f

常用参数:

1.合并DataFrame对象列表,如[df1, df2]

2.axis,沿着哪个轴进行合并。默认是axis=0,即沿着index进行拼接。

3.igonre_index,是否重构index,默认是False,不会重构。若为True,则会重构为0,1,2…的index。

pd.concat([a, b],ignore_incex=False) 
       clo1 col2 col3
index1    1    2    3
index2    4    5    6
index3    a    b    c
index4    d    e    f

pd.concat([a, b],ignore_index=True)
  clo1 col2 col3
0    1    2    3
1    4    5    6
2    a    b    c
3    d    e    f

九、引用

我只是把我借鉴的文章总结到了一起,下面是原文,如果有大佬发现我用了你的文章但是没有写,可以告诉我,我加上哦~

https://blog.csdn.net/MrRenLG/article/details/90516271
https://blog.csdn.net/starmoth/article/details/84779622?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
https://blog.csdn.net/butterfly1107/article/details/80091764
https://blog.csdn.net/qq_21046135/article/details/79210906
https://blog.csdn.net/W_weiying/article/details/81411257
https://blog.csdn.net/li_0891/article/details/81020657?ops_request_misc=%7B%22request%5Fid%22%3A%22158305457319726867819268%22%2C%22scm%22%3A%2220140713.130056874…%22%7D&request_id=158305457319726867819268&biz_id=0&utm_source=distribute.pc_search_result.none-task
https://blog.csdn.net/xun527/article/details/100537210?ops_request_misc=%7B%22request%5Fid%22%3A%22158305537419195239838190%22%2C%22scm%22%3A%2220140713.130056874…%22%7D&request_id=158305537419195239838190&biz_id=0&utm_source=distribute.pc_search_result.none-task
https://blog.csdn.net/The_Time_Runner/article/details/88581293?ops_request_misc=%7B%22request%5Fid%22%3A%22158313593319725222412037%22%2C%22scm%22%3A%2220140713.130056874…%22%7D&request_id=158313593319725222412037&biz_id=0&utm_source=distribute.pc_search_result.none-task
https://blog.csdn.net/weixin_43553694/article/details/92798367?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165246769616780357218331%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=165246769616780357218331&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v1~rank_v31_ecpm-1-92798367-null-null.142v9pc_search_result_cache,157v4control&utm_term=pandas+dataframe%E6%98%BE%E7%A4%BA%E8%AE%BE%E7%BD%AE&spm=1018.2226.3001.4187
https://blog.csdn.net/dili8870/article/details/101506598?ops_request_misc=%7B%22request%5Fid%22%3A%22158306332319725222459523%22%2C%22scm%22%3A%2220140713.130056874…%22%7D&request_id=158306332319725222459523&biz_id=0&utm_source=distribute.pc_search_result.none-task
https://blog.csdn.net/sinat_29675423/article/details/87972498?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
https://blog.csdn.net/weixin_39791387/article/details/82851773?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159782481519724848354144%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=159782481519724848354144&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v3~pc_rank_v2-2-82851773.first_rank_ecpm_v3_pc_rank_v2&utm_term=datafram%E5%8E%BB%E9%87%8D&spm=1018.2118.3001.4187
https://blog.csdn.net/weixin_41300650/article/details/102693025?biz_id=102&utm_term=datafram%20merge%E5%8F%82%E6%95%B0&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-0-102693025&spm=1018.2118.3001.4187
https://blog.csdn.net/Im_Chenxi/article/details/80398396?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159782465319725219908540%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=159782465319725219908540&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v3~pc_rank_v2-1-80398396.first_rank_ecpm_v3_pc_rank_v2&utm_term=datafram+contact%E5%90%88%E5%B9%B6&spm=1018.2118.3001.4187
https://blog.csdn.net/W_weiying/article/details/84618685?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159543216419724835810344%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=159543216419724835810344&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v3~pc_rank_v2-3-84618685.first_rank_ecpm_v3_pc_rank_v2&utm_term=dataframe%E6%8C%87%E5%AE%9A%E8%A1%8C%E5%88%97&spm=1018.2118.3001.4187
https://blog.csdn.net/luocheng7430/article/details/80330566?biz_id=102&utm_term=dataframe%E5%88%A0%E9%99%A4%E6%8C%87%E5%AE%9A%E8%A1%8C&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-0-80330566&spm=1018.2118.3001.4187
https://blog.csdn.net/W_weiying/article/details/84618685?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159543216419724835810344%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=159543216419724835810344&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v3~pc_rank_v2-3-84618685.first_rank_ecpm_v3_pc_rank_v2&utm_term=dataframe%E6%8C%87%E5%AE%9A%E8%A1%8C%E5%88%97&spm=1018.2118.3001.4187
https://blog.csdn.net/sinat_35930259/article/details/79887021?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159747350319726869038072%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=159747350319726869038072&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v3~pc_rank_v2-1-79887021.first_rank_ecpm_v3_pc_rank_v2&utm_term=datafram+merge&spm=1018.2118.3001.4187

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值