pandas操作Series和DataFrame的基本功能

reindex:重新索引

pandas对象有一个重要的方法reindex,作用:创建一个适应新索引的新对象

以Series为例

 1 >>> series_obj = Series([4.5,1.3,5,-5.5],index=(‘a‘,‘b‘,‘c‘,‘d‘))
 2 >>> series_obj
 3 a    4.5
 4 b    1.3
 5 c    5.0
 6 d   -5.5
 7 dtype: float64
 8 >>> obj2 = series_obj.reindex([‘a‘,‘b‘,‘c‘,‘e‘,‘f‘])
 9 >>> obj2
10 a    4.5
11 b    1.3
12 c    5.0
13 e    NaN
14 f    NaN
15 dtype: float64

重新索引的时候可以自动填充Nan值

1 >>> obj3 = series_obj.reindex([‘a‘,‘b‘,‘c‘,‘e‘,‘f‘],fill_value=‘0‘)
2 >>> obj3
3 a    4.5
4 b    1.3
5 c      5
6 e      0
7 f      0

对于时间序列这样的有序数据,重新索引可能需要做一些插值操作,reindex的method参数提供此功能。

method的可选选项有:

ffill或pad :前向填充或搬运值

bfill或backfill:后向填充或搬运值

不存在前向或后项的行自动填充Nan

 1 >>> obj4 = Series([‘red‘,‘blue‘,‘green‘],index=[0,2,4])
 2 >>> obj4
 3 0      red
 4 2     blue
 5 4    green
 6 dtype: object
 7 >>> obj4.reindex(range(6),method=‘ffill‘)
 8 0      red
 9 1      red
10 2     blue
11 3     blue
12 4    green
13 5    green
14 dtype: object

DataFrame的重新索引

只传入一个序列的时候,默认是重新索引“行”,可以用关键字参数来定义行索引(index)和列索引(columns)。

 1 >>> frame = DataFrame(np.arange(9).reshape((3,3)),index = [‘a‘,‘b‘,‘c‘],columns = [‘Ohio‘,‘Texas‘,"Cali"])
 2 >>> frame2 = frame.reindex([‘a‘,‘b‘,‘c‘,‘d‘])
 3 >>> frame2
 4    Ohio  Texas  Cali
 5 a   0.0    1.0   2.0
 6 b   3.0    4.0   5.0
 7 c   6.0    7.0   8.0
 8 d   NaN    NaN   NaN
 9
10 >>> frame3 = frame.reindex(columns = [‘Ohio‘,‘Texas‘,‘Cali‘,‘Wile‘],index=[‘a‘,‘b‘,‘c‘,‘d‘],fill_value=4)
11 >>> frame3
12    Ohio  Texas  Cali  Wile
13 a     0      1     2     4
14 b     3      4     5     4
15 c     6      7     8     4
16 d     4      4     4     4
17 >>>

如果对DataFrame的行和列重新索引的时候,插值只能按行应用

如果利用ix的标签索功能,重新索引会变得更简洁

1 >>> frame5 = frame.ix[[‘a‘,‘b‘,‘c‘,‘d‘], [‘Ohio‘,‘Texas‘,‘Cali‘,‘Wile‘]]
2 >>> frame5
3    Ohio  Texas  Cali  Wile
4 a   0.0    1.0   2.0   NaN
5 b   3.0    4.0   5.0   NaN
6 c   6.0    7.0   8.0   NaN
7 d   NaN    NaN   NaN   NaN

drop:丢弃指定轴上的项

>>> obj = Series(np.arange(5),index=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘])
>>> obj
a    0
b    1
c    2
d    3
e    4
dtype: int32
>>> new_obj = obj.drop(‘b‘)
>>> new_obj
a    0
c    2
d    3
e    4

>>> new_obj2 = obj.drop([‘b‘,‘c‘])
>>> new_obj2
a    0
d    3
e    4
dtype: int32

#dataframe
>>> frame = DataFrame(np.arange(16).reshape((4,4)),index=[‘a‘,‘b‘,‘c‘,‘d‘],columns=[‘one‘,‘two‘,‘three‘,‘four‘])
>>> frame
   one  two  three  four
a    0    1      2     3
b    4    5      6     7
c    8    9     10    11
d   12   13     14    15
>>> new_frame = frame.drop(‘a‘)
>>> new_frame
   one  two  three  four
b    4    5      6     7
c    8    9     10    11
d   12   13     14    15
>>> new_frame2 = frame.drop([‘two‘,‘four‘],axis = 1)
>>> new_frame2
   one  three
a    0      2
b    4      6
c    8     10
d   12     14

索引、选取和过滤

Series的索引,既可以是类似NumPy数组的索引,也可以是自定义的index

>>> obj
a    0
b    1
c    2
d    3
e    4
dtype: int32
>>> obj[‘a‘]
0
>>> obj[1]
1注意:利用标签的切片运算,标签的右侧是封闭区间的,即包含末端。
>>> obj[‘a‘:‘c‘]
a    0
b    1
c    2
dtype: int32
>>> obj[3:4]
d    3
dtype: int32
>>> obj[2:3]
c    2
dtype: int32
>>> obj[[3,1]]
d    3
b    1
dtype: int32
>>> obj[[‘a‘,‘c‘]]
a    0
c    2
dtype: int32
>>>

通过索引修改值

>>> obj[[‘b‘,‘d‘]] *=2
>>> obj
a    0
b    2
c    2
d    6
e    4
dtype: int32

dataframe的索引:

通过直接索引只能获取列

>>> frame
   one  two  three  four
a    0    1      2     3
b    4    5      6     7
c    8    9     10    11
d   12   13     14    15
>>> frame[‘a‘]
KeyError: ‘a‘
>>> frame[‘one‘]
a     0
b     4
c     8
d    12
Name: one, dtype: int32
>>> frame[[‘one‘,‘four‘]]
   one  four
a    0     3
b    4     7
c    8    11
d   12    15

通过切片或布尔型数组,选取的是行

>>> frame[1:3] #不闭合区间
   one  two  three  four
b    4    5      6     7
c    8    9     10    11
>>> frame[frame[‘three‘] > 8]
   one  two  three  four
c    8    9     10    11
d   12   13     14    15
>>>

DataFrame的索引字段ix

>>> frame.ix[‘a‘] #按照行索引
one      0
two      1
three    2
four     3
Name: a, dtype: int32
>>> frame.ix[[‘b‘,‘d‘]]
   one  two  three  four
b    4    5      6     7
d   12   13     14    15
>>> frame.ix[1]#同样是按照行索引
one      4
two      5
three    6
four     7
Name: b, dtype: int32
>>> frame.ix[1:3]
   one  two  three  four
b    4    5      6     7
c    8    9     10    11
>>> frame.ix[1:2,[2,3,1]]
   three  four  two
b      6     7    5
>>> frame.ix[1:3,[2,3,1]]
   three  four  two
b      6     7    5
c     10    11    9
>>> frame.ix[[‘b‘,‘d‘],[‘one‘,‘three‘]]
   one  three
b    4      6
d   12     14
>>> frame.ix[[‘b‘,‘d‘],[3,1,2]]
   four  two  three
b     7    5      6
d    15   13     14
>>> frame.ix[:,[2,3,1]]# 选取所有行
   three  four  two
a      2     3    1
b      6     7    5
c     10    11    9
d     14    15   13

>>> frame.ix[frame.three >5,:3]
one two three
b 4 5 6
c 8 9 10
d 12 13 14

算术运算和数据对齐

>>> s1 = Series([1.3,4.5,6.6,3.4],index=[‘a‘,‘b‘,‘c‘,‘d‘])
>>> s2 = Series([1,2,3,4,5,6,7],index=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘])
>>> s1+s2
a    2.3
b    6.5
c    9.6
d    7.4
e    NaN
f    NaN
g    NaN
dtype: float64
#不重叠的索引处引入缺失值
#DataFrame也是同理

再算术方法中填充缺失值

>>> df1 = DataFrame(np.arange(12).reshape((3,4)),columns=list(‘abcd‘))
>>> df2 = DataFrame(np.arange(20).reshape((4,5)),columns=list(‘abcde‘))
>>> df1+df2#普通的算术运算会产生缺失值
      a     b     c     d   e
0   0.0   2.0   4.0   6.0 NaN
1   9.0  11.0  13.0  15.0 NaN
2  18.0  20.0  22.0  24.0 NaN
3   NaN   NaN   NaN   NaN NaN
#用算术运算方法,可以填充缺失值
>>> df1.add(df2,fill_value=0)
      a     b     c     d     e
0   0.0   2.0   4.0   6.0   4.0
1   9.0  11.0  13.0  15.0   9.0
2  18.0  20.0  22.0  24.0  14.0
3  15.0  16.0  17.0  18.0  19.0
>>>

算术运算方法有

add 加法

sub 减法

div 除法

mul 乘法

DataFrame和Series之间的运算

>>> frame
   one  two  three  four
a    0    1      2     3
b    4    5      6     7
c    8    9     10    11
d   12   13     14    15
>>> series = frame.ix[0]
>>> series
one      0
two      1
three    2
four     3
Name: a, dtype: int32
>>> frame - series
   one  two  three  four
a    0    0      0     0
b    4    4      4     4
c    8    8      8     8
d   12   12     12    12
>>>

两者之间的运算会将Series的索引匹配到DataFrame的列,然后沿着行一直向下广播。

如果某个索引值在DataFrame的列或Series的索引中找不到,则参与运算的连个对象就会被重新索引以形成并集。

>>> series2 = Series(range(3),index = [‘two‘,‘four‘,‘five‘])
>>> frame +series2
   five  four  one  three   two
a   NaN   4.0  NaN    NaN   1.0
b   NaN   8.0  NaN    NaN   5.0
c   NaN  12.0  NaN    NaN   9.0
d   NaN  16.0  NaN    NaN  13.0

如果希望匹配行,且在列上传播,则必须使用算术方法

>>> series3 = frame[‘two‘]
>>> frame.sub(series3,axis = 0)
   one  two  three  four
a   -1    0      1     2
b   -1    0      1     2
c   -1    0      1     2
d   -1    0      1     2
>>>

原文地址:https://www.cnblogs.com/zuoshoushizi/p/8733153.html

时间: 2024-09-30 07:03:40

pandas操作Series和DataFrame的基本功能的相关文章

Pandas之Series和Dataframe

# Series 数据结构 # Series 是带有标签的一维数组,可以保存任何数据类型(整数,字符串,浮点数,Python对象等),轴标签统称为索引 import numpy as np import pandas as pd # 导入numpy.pandas模块 s = pd.Series(np.random.rand(5)) print(s) print(type(s)) # 查看数据.数据类型 print(s.index,type(s.index)) print(s.values,typ

pandas 的数据结构(Series, DataFrame)

Pandas 讲解 Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的. Pandas 纳入了大量库和一些标准的数据模型,提供了高效地操作大型数据集所需的工具. pandas提供了大量能使我们快速便捷地处理数据的函数和方法.你很快就会发现,它是使Python成为强大而高效的数据分析环境的重要因素之一. Series:一维数组,与Numpy中的一维array类似. 二者与Python基本的数据结构List也

Pandas初体验之数据结构——Series和DataFrame

Pandas是为了解决数据分析任务而创建的,纳入了大量的库和标准数据模型,提供了高效地操作大型数据集所需的工具. 对于Pandas包,在Python中常见的导入方法如下: from pandas import Series,DataFrame import pandas as pd 首先,我们需要对于Series和DataFrame有个基本的了解: Series:一维数组,类似于Python中的基本数据结构list,区别是Series只允许存储相同的数据类型,这样可以更有效的使用内存,提高运算效

利用 Python 进行数据分析(八)pandas 基本操作(Series 和 DataFrame)

一.reindex() 方法:重新索引 针对 Series   重新索引指的是根据index参数重新进行排序. 如果传入的索引值在数据里不存在,则不会报错,而是添加缺失值的新行. 不想用缺失值,可以用 fill_value 参数指定填充值. 例如: fill_value 会让所有的缺失值都填充为同一个值,如果不想这样而是用相邻的元素(左或者右)的值填充,则可以用 method 参数,可选的参数值为 ffill 和 bfill,分别为用前值填充和用后值填充: 针对 DataFrame   重新索引

pandas-06 Series和Dataframe的排序操作

pandas-06 Series和Dataframe的排序操作 对pandas中的Series和Dataframe进行排序,主要使用sort_values()和sort_index(). DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last') by:列名,按照某列排序 axis:按照index排序还是按照column排序 ascending:是否升

利用 Python 进行数据分析(七)- pandas 简单介绍(Series和DataFrame)

一.pandas 是什么 pandas 是基于 NumPy 的一个 Python 数据分析包,主要目的是为了数据分析.它提供了大量高级的数据结构和对数据处理的方法. pandas 有两个主要的数据结构:Series 和 DataFrame. 二.Series Series 是一个一维数组对象 ,类似于 NumPy 的一维 array.它除了包含一组数据还包含一组索引,所以可以把它理解为一组带索引的数组. 将 Python 数组转换成 Series 对象: 将 Python 字典转换成 Serie

pandas操作行集锦

pandas移花接木 数据准备两表: 我们接下来要进行的操作: 增 将两表进行合并 # 把两张表合并,但是这样有问题,索引会重复的进行0-19 students = page_001.append(page_002) students # 我们需要做一步操作,将索引全部重新排列,reset_index同时还要将原索引删除drop=True,这样就OK students.reset_index(drop=True) 追加一行数据到最后 # 这里必须开启ignore_index告诉pandas直接给

Pandas操作数据库及保存csv

数据的保存 import pandas as pd import numpy as np from pandas import Series col_db = [['one',1,2,3,4,np.nan],['two',5,6,8,'world',np.nan],['three',9,10,11,12,'foo']] data = pd.DataFrame(col_db,columns = ['somthing','a','b','c','d','message']) data somthin

使用pandas操作MySQL数据库

转载(有添加.修改)作者:但盼风雨来_jc链接:https://www.jianshu.com/p/238a13995b2b來源:简书著作权归作者所有.商业转载请联系作者获得授权,非商业转载请注明出处. 本次分享将介绍如何在Python中使用Pandas库实现MySQL数据库的读写.首先我们需要了解点ORM方面的知识 ORM技术   对象关系映射技术,即ORM(Object-Relational Mapping)技术,指的是把关系数据库的表结构映射到对象上,通过使用描述对象和数据库之间映射的元数