精华内容
下载资源
问答
  • apply Numpy 的ufuncs通用函数(元素级数组方法)也可用于操作pandas对象: ...许多最为常见的数组统计功能都被实现成DataFrame方法(如summean), 因此无需使用apply方法。 除标量外, 传递给apply的...

     

    apply

    Numpy 的ufuncs通用函数(元素级数组方法)也可用于操作pandas对象:

    另一个常见的操作是,将函数应用到由各列或行所形成的一维数组上。Dataframe的apply方法即可实现此功能:

    sum 和mean

    许多最为常见的数组统计功能都被实现成DataFrame的方法(如sum和mean), 因此无需使用apply方法。

    除标量外, 传递给apply的函数还可以返回由多个值组成的Series:

     

    元素级 python函数也可以用,格式化浮点值, applymap方法

     

    之所以叫做applymap, 是因为Series有一个用于应用元素级函数的map方法:

     

    展开全文
  • python数据分析工具pandas中DataFrame和Series作为主要的数据结构. 本文主要是介绍如何对DataFrame数据进行操作并结合一个实例测试操作函数。 1)查看DataFrame数据及属性 df_obj = DataFrame() #创建DataFrame对象...
  • 前言 配置的虚拟机为Centos6.7系统,hadoop版本为2.6.0版本,先前已经完成搭建CentOS部署Hbase、CentOS6.7...Spark的组件Spark SQL的部署:Spark SQL CLI部署CentOS分布式集群Hadoop上方法。 配置JDK1.8、Scala1...

     


    前言

    配置的虚拟机为Centos6.7系统,hadoop版本为2.6.0版本,先前已经完成搭建CentOS部署HbaseCentOS6.7搭建Zookeeper编写MapReduce前置插件Hadoop-Eclipse-Plugin 安装。在此基础上完成了Hive详解以及CentOS下部署Hive和MysqlSpark框架在CentOS下部署搭建。Spark的组件Spark SQL的部署:Spark SQL CLI部署CentOS分布式集群Hadoop上方法

    配置JDK1.8、Scala11.12

    本文将介绍DataFrame基础操作以及实例运用,重点介绍直接在DataFrame对象上查询的方法。


    DataFrame查询操作

    第一种方法是将DataFrame注册成为临时表,通过SQL语句进行查询。

    第二种方法是直接在DataFrame对象上进行查询,DataFrame的查询操作也是一个懒操作,只有触发Action操作才会进行计算并返回结果。

    DataFrame常用查询结果:

    方法 描述
    where 条件查询
    select/selectExpr/col/apply 查询指定字段的数据信息
    limit 查询前n行记录
    order by 排序查询
    group by 分组查询
    join 连接查询

     

    对于连接查询有两份数据用户对电影评分数据ratings.dat和用户的基本信息数据users.dat。

    ratings.dat4个字段分别为:UserID,MovieID,Rating,Timestamp

    users.dat5个字段分别为:UserID,Gender,Age,Occupation,Zip-code

    首先将文件导入,创建两个case class:

    (一不小心敲错了几下~)

    1.条件查询

    (1)where

    DataFrame可以使用where(conditionExpr:String)根据指定条件进行查询,参数中可以使用and或or,该方法的返回结果仍为DataFrame类型。

    (2)filter

    filter和where使用方法一样。

     2.查询指定字段的数据信息

    (1)select:获取指定字段值

    select方法根据传入的string类型字段名获取指定字段的值,以DataFrame类型返回。

    (2)selectExpr:对指定字段进行特殊处理

    selectExpr可对字段的名称进行替换也可对字段对于的数值进行替换,原表不变:

    基本看一眼程序就知道是干什么的,很简单。

     (3)col/apply

    col或者apply也可以获取DataFrame指定字段,但是只能获取一个字段,并且返回对象为Column类型。

    3.limit 

    limit方法获取指定DataFrame的前n行记录,得到一个新的DataFrame对象。不同于take与head,limit方法不是Action操作。

    4.orderBy/sort

    orderBy方法是根据指定字段排序,默认为升序排序。若是降序可以用三种方法来表示

    orderBy(desc.("userId"))

    orderBy($"userId".desc)

    orderBy(-user("userId"))

    sort方法和orderBy方法一样 

     5.groupBy

    groupBy方法是根据字段进行分组操作,groupBy方法有两种调用方式,可以传入String类型的字段名,也可传入Column类型的对象。groupBy返回的是 RelationalGroupedDataset 对象。

    GroupedData常用方法

    方法 描述
    max(colNames:String) 获取分组中指定字段或者所有的数值类型字段的最大值
    min(colNames:String) 获取分组中指定字段或者所有的数值类型字段的最小值
    mean(colNames:String) 获取分组中指定字段或者所有的数值类型字段的平均值
    sum(colNames:String) 获取分组中指定字段或者所有的数值类型字段的值的和
    count() 获取分组中元素的个数

     agg(expers:column*) 返回dataframe类型 。

     

    6.join

    join可连接两个表进行操作,数据库常用函数。

    join常用方法:

    方法 描述
    join(right:DataFrame) 两个表做笛卡尔积
    join(right:DataFrame,joinExprs:Column) 根据两表中相同的某个字段进行连接
    join(right:DataFrame,joinExprs:Column,joinType:String) 根据两表中相同的某个字段进行连接并指定连接类型

    spark2.x版本中默认不支持笛卡尔积操作。通过参数spark.sql.crossJoin.enabled开启,方式如下:

    spark.conf.set("spark.sql.crossJoin.enabled", "true")
     

    DataFrame输出操作

    DataFrame API在提供了很多输出操作方法。save方法可以将DataFrame保存成文件,save操作有一个可选参数SaveMode,用这个参数可以指定如何处理数据已经存在的情况。另外,在使用HiveContext的时候,DataFrame可以用saveAsTable方法将数据保存成持久化的表。与registerTempTable不同,saveAsTable会将DataFrame的实际内容保存下来,并且在HiveMetastore中创建一个游标指针。持久化的表会一直保存,即使spark程序重启也没有影响,只要连接到同一个metastore就可以读取其数据。读取持久化表示,只需要用表明作为参数,调用SQLContext.table方法即可得到对应的DataFrame。

    将DataFrame保存到同一个文件里面有两种方法。

    (1)首先创建一个Map对象,用于存储一些save函数需要用到的一些数据,这里将指定保存文件路径及JSON文件的头信息


    (2)从DataFrame对象中选择出userId、gender和age

    (3)调用save函数保存(2)中的DataFrame数据到copyOfUser.json文件夹中

    要加载SaveMode需要先加载SQLContext

    mode函数可以接收的参数有Overwrite、Append、Ignore和ErrorIfExists。

    Overwirte代表覆盖目录之前就存在的数据,Append代表给指导目录下追加数据,Ignore代表如果目录下已经有的文件,那就什么都不执行,ErrorIfExits代表如果保存目录下存在的文件,那么跑出相应的异常。

    方法二为直接调用save方法


    参阅

    Spark DataSet常用action,及操作汇总

    spark学习进度21(聚合操作、连接操作)

    展开全文
  • 转载自levi的博客:pandas.DataFrame.copy函数方法的使用 DataFrame.copy(deep=True) 复制此对象的索引数据。 当deep=True(默认)时,将使用调用对象的数据索引的副本创建新对象。对副本的数据或索引的修改不会...

    转载自levi的博客:pandas.DataFrame.copy函数方法的使用

    DataFrame.copy(deep=True)

    复制此对象的索引和数据。

    deep=True(默认)时,将使用调用对象的数据和索引的副本创建新对象。对副本的数据或索引的修改不会反映在原始对象中(请参阅下面的注释)。

    deep=False,将创建一个新对象而不复制调用对象的数据或索引(仅复制对数据和索引的引用)。对原始数据的任何更改都将反映在浅层副本中(反之亦然)。

    属性 说明
    参数 deepbool,默认为True
    创建深层副本,包括数据和索引的副本。随着deep=False无论是指数还是数据复制。
    返回 copySeriesDataFramePanel
    对象类型与调用者匹配。

    Notes

    deep=True,数据被复制但实际的Python对象不会被递归复制,只能引用该对象。这与标准库中的copy.deepcopy形成对比,后者以递归方式复制对象数据(请参阅下面的示例)。

    在Index复制对象时deep=True,由于性能原因,不会复制基础numpy数组。由于Index是不可变的,因此可以安全地共享基础数据并且不需要副本。

    例子

    >>> s = pd.Series([1, 2], index=["a", "b"])
    >>> s
    a    1
    b    2
    dtype: int64
    >>> s_copy = s.copy()
    >>> s_copy
    a    1
    b    2
    dtype: int64
    

    浅拷贝与默认(深层)拷贝:

    >>> s = pd.Series([1, 2], index=["a", "b"])
    >>> deep = s.copy()
    >>> shallow = s.copy(deep=False)
    

    浅拷贝与原始数据共享数据和索引。

    >>> s is shallow
    False
    >>> s.values is shallow.values and s.index is shallow.index
    True
    

    深层副本具有自己的数据和索引副本。

    >>> s is deep
    False
    >>> s.values is deep.values or s.index is deep.index
    False
    

    浅拷贝和原始数据共享的数据的更新反映在两者中; 深拷贝保持不变。

    >>> s[0] = 3
    >>> shallow[1] = 4
    >>> s
    a    3
    b    4
    dtype: int64
    >>> shallow
    a    3
    b    4
    dtype: int64
    >>> deep
    a    1
    b    2
    dtype: int64
    

    请注意,复制包含Python对象的对象时,深层副本将复制数据,但不会以递归方式复制。更新嵌套数据对象将反映在深层副本中。

    >>> s = pd.Series([[1, 2], [3, 4]])
    >>> deep = s.copy()
    >>> s[0][0] = 10
    >>> s
    0    [10, 2]
    1     [3, 4]
    dtype: object
    >>> deep
    0    [10, 2]
    1     [3, 4]
    dtype: object
    
    展开全文
  • DataFrame 数据合并方法

    千次阅读 2017-11-07 21:44:59
    DataFrame 数据合并方法引言Pandas 是数据分析最常用的工具包之一,DataFrame是Pandas最常用的数据结构。在使用Pandas做数据分析时会经常用到类似...具有数据合并功能的函数一共有三个,分别是merge(),concat()join

    DataFrame 数据合并方法

    引言

    Pandas 是数据分析最常用的工具包之一,DataFrame是Pandas最常用的数据结构。在使用Pandas做数据分析时会经常用到类似于数据库连表查询的需求,每次将表格读入数据库进行连表查询,未免太过繁琐。值得庆幸的是Pandas提供了强大基于DataFrame的数据合并功能。具有数据合并功能的函数一共有三个,分别是merge(),concat()和join(),下面我们将分贝进行学习。

    merge()

    功能解读

    用于通过一个或多个键将两个数据集的行连接起来,类似于 SQL 中的 JOIN。该函数的典型应用场景是,针对同一个主键存在两张包含不同字段的表,现在我们想把他们整合到一张表里。在此典型情况下,结果集的行数并没有增加,列数则为两个元数据的列数和减去连接键的数量。对于多对多连接,结果采用的是行的笛卡尔积。

    原型

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

    参数解读

    • left与right:指定要合并的DataFrame
    • how 参数指的是当左右两个对象中存在不重合的键时,取结果的方式:inner 代表交集;outer 代表并集;left 和 right 分别为取一边。
    • on 用于显示指定列名(键名),如果该列在两个对象上的列名不同,则可以通过 left_on, right_on 来分别指定。或者想直接使用行索引作为连接键的话,就将 left_index, right_index 设为 True。
    • suffixes=(‘_x’,’_y’) 指的是当左右对象中存在除连接键外的同名列时,结果集中的区分方式,可以各加一个小尾巴。
    • left_on:左则DataFrame中用作连接键的列名;这个参数在左右DataFrame列名不相同,但代表的含义相同时非常有用。
    • right_on:右则DataFrame中用作 连接键的列名
    • left_index:使用左则DataFrame中的行索引做为连接键
    • right_index:使用右则DataFrame中的行索引做为连接键
    • sort:默认为True,将合并的数据进行排序。在大多数情况下设置为False可以提高性能
    • suffixes:字符串值组成的元组,用于指定当左右DataFrame存在相同列名时在列名后面附加的后缀名称,默认为(‘_x’,’_y’)
    • copy:默认为True,总是将数据复制到数据结构中;大多数情况下设置为False可以提高性能
    • indicator:v0.17.0 版本的pandas开始还支持一个indicator的参数,如果置True的时候,输出结果会增加一列 ’ _merge’。_merge列可以取三个值: left_only 只在左表中,right_only 只在右表中,both 两个表中都有

    merge 的一些特性示例

    • 默认以重叠的列名当做连接键
    df1= pd.DataFrame({'key':['a','b','b'],'data1':range(3)})
    df2= pd.DataFrame({'key':['a','b','c'],'data2':range(3)})
    print(df1)
    print(df2)
    df3 = pd.merge(df1,df2)   #没有指定连接键,默认用重叠列名
    print(df3)
       data1 key
    0      0   a
    1      1   b
    2      2   b
       data2 key
    0      0   a
    1      1   b
    2      2   c
       data1 key  data2
    0      0   a      0
    1      1   b      1
    2      2   b      1
    • 默认做inner连接(取key的交集)
    df4 = pd.merge(df2,df1) #默认内连接,可以看见c没有连接上。
    print(df4)
    df5 = pd.merge(df2,df1,how='left') #通过how,指定连接方式,连接方式还有(left,right,outer)
    print(df5)
       data2 key  data1
    0      0   a      0
    1      1   b      1
    2      1   b      2
       data2 key  data1
    0      0   a    0.0
    1      1   b    1.0
    2      1   b    2.0
    3      2   c    NaN
    • 多键连接时将连接键组成列表传入
    left=pd.DataFrame({'key1':['foo','foo','bar'],
                       'key2':['one','two','one'],
                       'lval':[1,2,3]})
    print(left)
    right=pd.DataFrame({'key1':['foo','foo','bar','bar'],
                        'key2':['one','one','one','two'],
                        'lval':[4,5,6,7]})
    print(right)
    df6 = pd.merge(left,right,on=['key1','key2'],how='outer')  #传入数组
    print(df6)
      key1 key2  lval
    0  foo  one     1
    1  foo  two     2
    2  bar  one     3
      key1 key2  lval
    0  foo  one     4
    1  foo  one     5
    2  bar  one     6
    3  bar  two     7
      key1 key2  lval_x  lval_y
    0  foo  one     1.0     4.0
    1  foo  one     1.0     5.0
    2  foo  two     2.0     NaN
    3  bar  one     3.0     6.0
    4  bar  two     NaN     7.0
    • 如果两个对象的列名不同,可以分别指定
    right=pd.DataFrame({'key3':['foo','foo','bar','bar'],
                        'key4':['one','one','one','two'],
                        'lval':[4,5,6,7]})
    print(right)
    df7 = pd.merge(left,right,left_on='key1',right_on='key3')  #传入数组
    print(df7)
      key3 key4  lval
    0  foo  one     4
    1  foo  one     5
    2  bar  one     6
    3  bar  two     7
      key1 key2  lval_x key3 key4  lval_y
    0  foo  one       1  foo  one       4
    1  foo  one       1  foo  one       5
    2  foo  two       2  foo  one       4
    3  foo  two       2  foo  one       5
    4  bar  one       3  bar  one       6
    5  bar  one       3  bar  two       7
    • 以索引当做连接键,使用参数left_index=true,right_index=True
    left=pd.DataFrame({'key2':['one','two','one'],
                       'lval':[1,2,3]},
                      index=['foo','foo','bar'])
    print(left)
    right=pd.DataFrame({'key4':['one','one','one','two'],
                        'lval':[4,5,6,7]},
                       index=['foo','foo','bar','bar'])
    print(right)
    df8 = pd.merge(left,right,left_index=True,right_index=True)  #传入数组
    print(df8)
        key2  lval
    foo  one     1
    foo  two     2
    bar  one     3
        key4  lval
    foo  one     4
    foo  one     5
    bar  one     6
    bar  two     7
        key2  lval_x key4  lval_y
    bar  one       3  one       6
    bar  one       3  two       7
    foo  one       1  one       4
    foo  one       1  one       5
    foo  two       2  one       4
    foo  two       2  one       5
    • 可以一侧使用索引,一侧使用列值进行连接
    left=pd.DataFrame({'key1':['foo','foo','bar'],
                       'key2':['one','two','one'],
                       'lval':[1,2,3]})
    print(left)
    right=pd.DataFrame({'key4':['one','one','one','two'],
                        'lval':[4,5,6,7]},
                       index=['foo','foo','bar','bar'])
    print(right)
    df9 = pd.merge(left,right,left_on='key1',right_index=True)  #传入数组
    print(df9)
      key1 key2  lval
    0  foo  one     1
    1  foo  two     2
    2  bar  one     3
        key4  lval
    foo  one     4
    foo  one     5
    bar  one     6
    bar  two     7
      key1 key2  lval_x key4  lval_y
    0  foo  one       1  one       4
    0  foo  one       1  one       5
    1  foo  two       2  one       4
    1  foo  two       2  one       5
    2  bar  one       3  one       6
    2  bar  one       3  two       7

    join()

    功能解读

    join方法提供了一个简便的方法用于将两个DataFrame中的不同的列索引合并成为一个DataFrame。其中参数的意义与merge方法基本相同,只是join方法默认为左外连接how=left。可以连接多个DataFrame。

    原型

    join(self, other, on=None, how='left', lsuffix='', rsuffix='',sort=False)

    参数解读

    • how 和merge中的how参数一样,用来指定表合并保留数据的规则。
    • on 在实际应用中如果右表的索引值正是左表的某一列的值,这时可以通过将 右表的索引 和 左表的列 对齐合并这样灵活的方式进行合并。
    • suffix 和merge中的suffix参数一样

    实例

    • how 参数的实例
    data=pd.DataFrame([{"id":0,"name":'lxh',"age":20,"cp":'lm'},
                       {"id":1,"name":'xiao',"age":40,"cp":'ly'},
                       {"id":2,"name":'hua',"age":4,"cp":'yry'},
                       {"id":3,"name":'be',"age":70,"cp":'old'}],
                      index=['a','b','c','d'])
    data1=pd.DataFrame([{"sex":0},
                        {"sex":1},
                        {"sex":2}],
                       index=['a','b','e'])
    
    print(data)
    print(data1)
    
    print ('使用默认的左连接\r\n',data.join(data1))  
    print ('使用右连接\r\n',data.join(data1,how="right"))
    print ('使用内连接\r\n',data.join(data1,how='inner'))
    print ('使用全外连接\r\n',data.join(data1,how='outer'))
    age   cp  id  name
    a   20   lm   0   lxh
    b   40   ly   1  xiao
    c    4  yry   2   hua
    d   70  old   3    be
       sex
    a    0
    b    1
    e    2
    使用默认的左连接
        age   cp  id  name  sex
    a   20   lm   0   lxh  0.0
    b   40   ly   1  xiao  1.0
    c    4  yry   2   hua  NaN
    d   70  old   3    be  NaN
    使用右连接
         age   cp   id  name  sex
    a  20.0   lm  0.0   lxh    0
    b  40.0   ly  1.0  xiao    1
    e   NaN  NaN  NaN   NaN    2
    使用内连接
        age  cp  id  name  sex
    a   20  lm   0   lxh    0
    b   40  ly   1  xiao    1
    使用全外连接
         age   cp   id  name  sex
    a  20.0   lm  0.0   lxh  0.0
    b  40.0   ly  1.0  xiao  1.0
    c   4.0  yry  2.0   hua  NaN
    d  70.0  old  3.0    be  NaN
    e   NaN  NaN  NaN   NaN  2.0
    • on参数的实例
    left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3'],
                       'key': ['K0', 'K1', 'K0', 'K1']})
    
    right = pd.DataFrame({'C': ['C0', 'C1'],
                           'D': ['D0', 'D1']},
                           index=['K0', 'K1'])
    
    result = left.join(right, on='key')
    print(result)
        A   B key   C   D
    0  A0  B0  K0  C0  D0
    1  A1  B1  K1  C1  D1
    2  A2  B2  K0  C0  D0
    3  A3  B3  K1  C1  D1
    • 组合多个key不完全相同的dataframe
    left = pd.DataFrame({'v': [1, 2, 3]}, index=['K0', 'K1', 'K2'])
    right = pd.DataFrame({'v': [4, 5, 6]}, index=['K0', 'K0', 'K2'])
    right2 = pd.DataFrame({'v': [7, 8, 9]}, index=['K1', 'K1', 'K2'])
    
    result = left.join([right, right2])
    print(result)
        v_x  v_y    v
    K0    1  4.0  NaN
    K0    1  5.0  NaN
    K1    2  NaN  7.0
    K1    2  NaN  8.0
    K2    3  6.0  9.0
    • 组合key值相同的dataframe
    left = pd.DataFrame({'v1': [1, 2, 3]}, index=['K0', 'K1', 'K2'])
    right = pd.DataFrame({'v2': [4, 5, 6]}, index=['K0', 'K1', 'K2'])
    right2 = pd.DataFrame({'v3': [7, 8, 9]}, index=['K0', 'K1', 'K2'])
    
    result = left.join([right, right2])
    print(result)
        v1  v2  v3
    K0   1   4   7
    K1   2   5   8
    K2   3   6   9

    concat()

    功能解读

    concat方法可以沿着一条轴将多个对象堆叠到一起。相当于数据库中的全连接(UNION ALL),可以指定按某个轴进行连接,也可以指定连接的方式join(outer,inner 只有这两种)。与数据库不同的时concat不会去重,要达到去重的效果可以使用drop_duplicates方法。
    轴向连接 pd.concat() 就是单纯地把两个表拼在一起,这个过程也被称作连接(concatenation)、绑定(binding)或堆叠(stacking)。因此可以想见,这个函数的关键参数应该是 axis,用于指定连接的轴向。在默认的 axis=0 情况下,pd.concat([obj1,obj2])函数的效果与 obj1.append(obj2) 是相同的;而在 axis=1 的情况下,pd.concat([df1,df2],axis=1)的效果与 pd.merge(df1,df2,left_index=True,right_index=True,how='outer') 是相同的。
    可以理解为 concat 函数使用索引作为“连接键”。

    原型

    pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False)。 

    参数解读

    • objs 就是需要连接的对象集合,series,dataframe或者是panel构成的序列list;
    • axis 需要合并链接的轴,0是行,1是列
    • join 连接的方式 inner,或者outer

    实例

    纵向表连接

    • 相同column的表首尾相接
    import pandas as pd
    
    df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3'],
                         'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']},
                         index=[0, 1, 2, 3])
    
    
    df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                        'B': ['B4', 'B5', 'B6', 'B7'],
                         'C': ['C4', 'C5', 'C6', 'C7'],
                         'D': ['D4', 'D5', 'D6', 'D7']},
                          index=[4, 5, 6, 7])
    
    
    df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
                        'B': ['B8', 'B9', 'B10', 'B11'],
                         'C': ['C8', 'C9', 'C10', 'C11'],
                         'D': ['D8', 'D9', 'D10', 'D11']},
                         index=[8, 9, 10, 11])  
    
    frames = [df1, df2, df3]
    result = pd.concat(frames)
    print(result)
          A    B    C    D
    0    A0   B0   C0   D0
    1    A1   B1   C1   D1
    2    A2   B2   C2   D2
    3    A3   B3   C3   D3
    4    A4   B4   C4   D4
    5    A5   B5   C5   D5
    6    A6   B6   C6   D6
    7    A7   B7   C7   D7
    8    A8   B8   C8   D8
    9    A9   B9   C9   D9
    10  A10  B10  C10  D10
    11  A11  B11  C11  D11
    • axis=0时等价于append函数。append是series和dataframe的方法,使用它就是默认沿着列进行拼接(axis = 0,列对齐)
        A   B   C   D
    0  A0  B0  C0  D0
    1  A1  B1  C1  D1
    2  A2  B2  C2  D2
    3  A3  B3  C3  D3
    4  A4  B4  C4  D4
    5  A5  B5  C5  D5
    6  A6  B6  C6  D6
    7  A7  B7  C7  D7
    • keys参数可以用来给合并后的表增加key来区分不同的表数据来源
    result = pd.concat(frames, keys=['x', 'y', 'z'])
      A    B    C    D
    x 0    A0   B0   C0   D0
      1    A1   B1   C1   D1
      2    A2   B2   C2   D2
      3    A3   B3   C3   D3
    y 4    A4   B4   C4   D4
      5    A5   B5   C5   D5
      6    A6   B6   C6   D6
      7    A7   B7   C7   D7
    z 8    A8   B8   C8   D8
      9    A9   B9   C9   D9
      10  A10  B10  C10  D10
      11  A11  B11  C11  D11
    • 传入字典来增加分组键
    pieces = {'x': df1, 'y': df2, 'z': df3}
    result = pd.concat(pieces)
    print(result)
            A    B    C    D
    x 0    A0   B0   C0   D0
      1    A1   B1   C1   D1
      2    A2   B2   C2   D2
      3    A3   B3   C3   D3
    y 4    A4   B4   C4   D4
      5    A5   B5   C5   D5
      6    A6   B6   C6   D6
      7    A7   B7   C7   D7
    z 8    A8   B8   C8   D8
      9    A9   B9   C9   D9
      10  A10  B10  C10  D10
      11  A11  B11  C11  D11
    • 无视index的concat。如果两个表的index都没有实际含义,使用ignore_index参数,True,合并的两个表就睡根据列字段对齐,然后合并。最后再重新整理一个新的index。
    df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3'],
                         'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']},
                         index=[0, 1, 2, 3])
    df4 = pd.DataFrame({'B': ['B2', 'B3','B6', 'B7'],
                        'D': ['D2', 'D3','D6', 'D7'],
                        'F': ['D2', 'D3','D6', 'D7'],},
    result = pd.concat([df1, df4],ignore_index=True)
    print(result)
         A   B    C   D    F
    0   A0  B0   C0  D0  NaN
    1   A1  B1   C1  D1  NaN
    2   A2  B2   C2  D2  NaN
    3   A3  B3   C3  D3  NaN
    2  NaN  B2  NaN  D2   D2
    3  NaN  B3  NaN  D3   D3
    6  NaN  B6  NaN  D6   D6

    横向表拼接(行对齐)

    • 当axis = 1的时候,concat就是按照索引行对齐,然后将不同列名称的两张表合并
    df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3'],
                         'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']},
                         index=[0, 1, 2, 3])
    df4 = pd.DataFrame({'B': ['B2', 'B3','B6', 'B7'],
                        'D': ['D2', 'D3','D6', 'D7'],
                        'F': ['D2', 'D3','D6', 'D7'],},
                         index=[2, 3, 6, 7])
    result = pd.concat([df1, df4], axis=1)
    print(result)
         A    B    C    D    B    D    F
    0   A0   B0   C0   D0  NaN  NaN  NaN
    1   A1   B1   C1   D1  NaN  NaN  NaN
    2   A2   B2   C2   D2   B2   D2   D2
    3   A3   B3   C3   D3   B3   D3   D3
    6  NaN  NaN  NaN  NaN   B6   D6   D6
    7  NaN  NaN  NaN  NaN   B7   D7   D7
    • 加上join参数的属性,如果为‘inner’得到的是两表的交集,如果是outer,得到的是两表的并集。
    result = pd.concat([df1, df4], axis=1, join='inner')
    print(result)
        A   B   C   D   B   D   F
    2  A2  B2  C2  D2  B2  D2  D2
    3  A3  B3  C3  D3  B3  D3  D3
    • 如果有join_axes的参数传入,可以指定根据那个轴来对齐数据 .
      例如根据df1表对齐数据,就会保留指定的df1表的轴,然后将df4的表与之拼接。相当于左连接。
    result = pd.concat([df1, df4], axis=1, join_axes=[df1.index])
    print(result)
        A   B   C   D    B    D    F
    0  A0  B0  C0  D0  NaN  NaN  NaN
    1  A1  B1  C1  D1  NaN  NaN  NaN
    2  A2  B2  C2  D2   B2   D2   D2
    3  A3  B3  C3  D3   B3   D3   D3

    在dataframe中加入新的行

    append方法可以将 series 和 字典构成的数据作为dataframe的新一行插入。如果遇到两张表的列字段本来就不一样,但又想将两个表合并,其中无效的值用nan来表示。那么可以使用ignore_index来实现。

    s2 = pd.Series(['X0', 'X1', 'X2', 'X3'], index=['A', 'B', 'C', 'D'])
    result = df1.append(s2, ignore_index=True)
    print(result)
    dicts = [{'A': 1, 'B': 2, 'C': 3, 'X': 4},{'A': 5, 'B': 6, 'C': 7, 'Y': 8}] 
    result = df1.append(dicts, ignore_index=True)
    print(result)
        A   B   C   D
    0  A0  B0  C0  D0
    1  A1  B1  C1  D1
    2  A2  B2  C2  D2
    3  A3  B3  C3  D3
    4  X0  X1  X2  X3
        A   B   C    D    X    Y
    0  A0  B0  C0   D0  NaN  NaN
    1  A1  B1  C1   D1  NaN  NaN
    2  A2  B2  C2   D2  NaN  NaN
    3  A3  B3  C3   D3  NaN  NaN
    4   1   2   3  NaN  4.0  NaN
    5   5   6   7  NaN  NaN  8.0

    参考文章:
    1.【pandas】[3] DataFrame 数据合并,连接(merge,join,concat)
    2.Pandas数据合并
    3.pandas 之 concat
    4.PANDAS 数据合并与重塑(concat篇)
    5.PANDAS 数据合并与重塑(join/merge篇)

    展开全文
  • Dataframe的使用方法

    千次阅读 2017-07-19 15:50:45
    Pandas提供了大量的函数,本文无法全部覆盖,有兴趣的读者可以详细阅读官方说明文档或者利用 google 搜索更多相关的信息——网上有许多 StackOverflow 的问题一些介绍该软件库的技术博客。接下来我们将利用...
  • 前言 配置的虚拟机为Centos6.7系统,hadoop版本为2.6.0版本,先前已经完成搭建CentOS部署Hbase、CentOS6.7搭建...Spark的组件Spark SQL的部署:Spark SQL CLI部署CentOS分布式集群Hadoop上方法。 配置JDK1.8、Scal...
  • 本篇是DataFrame系列博文的,常用的基础方法。 以下面dataframe为案例: 1.查看有哪些列 data.columns Out[183]: Index(['a', 'b', 'c', 'd'], dtype='object') 2.查看索引 data.index Out[185]: Range...
  • PandasDataFrame类的方法

    2021-01-21 09:28:31
    这个函数会返回一个包含所有数据的Pandas DataFrame对象。 以下的方法都是基于这个对象的。 假如我们将数据都存储在housing这个Pandas DataFrame对象中: housing.head() 会返回数据的前五行内容 housing.info()...
  • DataFrame的ix方法

    千次阅读 2020-05-20 10:14:47
    关于Pandas——loc、iloc、ix 函数区别用法,可见博客: https://blog.csdn.net/u012736685/article/details/86610946 这里只是码一下, ix方法是包含首尾的,示例如下: print(data_set1[['Value']].ix[0:3, ...
  • python DataFrame的apply方法

    万次阅读 2018-01-24 21:03:59
    #函数应用映射 import numpy as np import pandas as pd df=pd.DataFrame(np.random.randn(4,3),columns=list('bde'),index=['utah','ohio','texas','oregon']) print(df) b d e utah -0.451195 -0
  • 当apply函数处理的不是单个元素,而是整个dataframe行或者列时,为保证apply方法最终返回dataframe,可以在定义操作函数返回值时,将返回值设定为与原来dataframe相同列index的series类型。 ...
  • pandas DataFrame的增删查改总结系列文章: pandas DaFrame的创建方法...在操作DataFrame时,肯定会经常用到loc,iloc,at等函数,各个函数看起来差不多,但是还是有很多区别的,我们一起来看下吧。 首先,还是列出...
  • pandas中Series和DataFrame的rank方法详解

    千次阅读 2018-01-20 01:47:09
    rank方法的作用是计算出axis方向上各个data的排名...函数原型 Series.rank(axis=0,method='average',numeric_only=None,na_option='keep',ascending=True,pct=False)该方法用来排名(名次值从1开始),它可以根...
  • (已经做了一些操作将Age为NaN的行提取出来并合并为一个dataframe,这里提取的是该dataframe的索引,道理操作是相似的,提取的代码没有贴上去是为了不显得太繁杂让读者看着繁琐) >>> index = unknown_age_Mr....
  • 背景PyODPS DataFrame 提供了类似 pandas 的...PyODPS DataFrame 除了支持类似 pandas 的 map apply 方法,也提供了 MapReduce API 来扩展 pandas 语法以适应大数据环境。PyODPS 的自定义函数是序列化到 MaxCo...
  • DataFrame类具有很多方法,下面做用法的介绍举例。 pandas.DataFrame学习系列2——函数方法(1) 1.abs(),返回DataFrame每个数值的绝对值,前提是所有元素均为数值型 1 import pandas as pd 2 import numpy...
  • groupby函数有很多妙用,从数据库得到的要分析的数据必然是粗粒度的数据,pandas提供类似于sql语句的工具进行数据分析挖掘,再结合seaborn的作图包,做数据探索分析就很美妙,看个例子: data['Current_Status']...
  • 我们经常会对DataFrame对象中的某些行或列,或者对DataFrame对象中的所有元素进行某种运算或操作,我们无需利用低效笨拙的循环,DataFrame给我们分别提供了相应的直接而简单的方法,apply()applymap()。...
  • 在操作DataFrame时,肯定会经常用到loc,iloc,at等函数,各个函数看起来差不多,但是还是有很多区别的,我们一起来看下吧。 首先,还是列出一个我们用的DataFrame,注意index一列,如下: 接下来,介绍下各个函数...
  • 参考:dataframe.apply官方文档 How to apply a function to two columns of Pandas dataframe python pandas- apply function ...在处理数据的时候想做时间的转换,抽取生日(格式如 1994-10-5)提取月份日期...
  • 1.dataframe和series中都有apply方法dataframe中的apply方法需要指定axis参数,是对一行或者一列进行操作,比如求一列的最大值与最小值之差等;series中的apply方法与map方法一样,都是作用于单个元素,所以不具有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 640
精华内容 256
关键字:

dataframe函数和方法