Python：pandas（二）——pandas函数

Python：pandas（一）

这一章翻译总结自：pandas官方文档——General functions

空值：pd.NaT、np.nan

//判断是否为空
if a is np.nan:
    ...

数据操作
melt	将DataFrame从一个宽类型转化为长类型；固定某一列，看该列变量其他列的值
pivot	用某些列将DataFrame变形（不是常见的大小变形）
cut	切割一个一维数据为离散的区间
qcut	与cut相似，区别在于cut是等长切割，qcut是等元素数切割
merge	连接
merge_ordered	连接并排序
merge_asof	连接并根据前后项为空值赋值
concat	连接series list中的series，指定连接维度；可以新建维度，比如把一维变二维、二维变三维（类似numpy中的concat）
	返回两个array——codes和uniques，第二个是原list中的不重复的所有元素，第一个是原数组中的元素在第二个array中的索引下标
unique	提取一个序列中的元素，不重复地保存到一个array中
wide_to_long	将属性行转换为数据列
缺省值处理
isna	检测一个obj（或其中的元素）是否为空值（这两种方法的用法相同）
isnull
notna	检查一个obj（或其中的元素）是否不是空值（与isna刚好相反）
notnull
转换
to_numeric	将一个序列中的元素全部数值化
时间数值处理
to_datetime	将数据转为datetime类型
to_timedelta	将数据转化为Timedelta类型
date_range	以固定频率返回一个DatetimeIndex（给出日期的开头结尾或频率，返回在这之间的日期），其中包含若干Datetime
bdate_range	同上以固定频率返回一个DatetimeIndex，区别在于返回是工作日的日期
period_range	同上，区别在于①输入的是period-like（'2017-01-01'）；②返回PeriodIndex
timedelta_range	同上，区别在于①输入的是timedelta-like（'1day'）；②返回TimedeltaIndex
分隔符处理
interval_range	以固定频率返回IntervalIndex（与上边的区别在于这里是区间）
评价
eval	解析一个Python表达式的string，并用该表达式对某个Python类型的数据进行各种运算，返回运算后的结果
util.hash_array	对一个一维array进行hash加密
util.hash_pandas_object	对一个Index、Series、DataFrame进行hash加密

1、pandas.melt

说明

将将一个DataFrame的一或多列确定为标识变量(id_vals)，由参数value_vars指定的列作为被测量变量，构建新的DataFrame，该DataFrame的列名为， [ id_vals , variable , value ]，目的是为了观测id_vals指定列的分量值。

pandas.melt(
    frame,
    id_vars=None,
    value_vars=None,
    var_name=None,
    value_name='value',
)

参数

参数	类型	默认值	说明
id_vars	list		标识列
value_vars	list		被测量列
var_name	str list	'variable'	被测量列的列名
var_name	str list	'value'	被测量列的值的列名

例子

df=pd.DataFrame({'A': {0: 'a', 1: 'b', 2: 'c'},
                   'B': {0: 1, 1: 3, 2: 5},
                   'C': {0: 2, 1: 4, 2: 6}})
df
   A  B  C
0  a  1  2
1  b  3  4
2  c  5  6
 
df.melt(id_vars=['A'],value_vars=['B'])
   A variable  value
0  a        B      1
1  b        B      3
2  c        B      5

这样，直接看出属性列'A'的各行的分量'B'的取值

2、pandas.pivot

pandas.pivot(
    data,
    index=None,
    columns=None,
    values=None
)

说明

用某些列将DataFrame变形

参数

参数	类型	说明
data	DataFrame	参与变形的DataFrame
index	str	用于构建新DataFrame索引列的列
columns	str或str list	用于构建新DataFrame数据列列名的列
values	str或str list	用于填充参数columns指定列的数据所在的列

例子

df = pd.DataFrame({'foo': ['one', 'one', 'one', 'two', 'two',
                           'two'],
                   'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
                   'baz': [1, 2, 3, 4, 5, 6],
                   'zoo': ['x', 'y', 'z', 'q', 'w', 't']})
df
    foo   bar  baz  zoo
0   one   A    1    x
1   one   B    2    y
2   one   C    3    z
3   two   A    4    q
4   two   B    5    w
5   two   C    6    t
 
df.pivot(index='foo', columns='bar', values='baz')
bar  A   B   C
foo
one  1   2   3
two  4   5   6

上文df.pivot(...)的意思是：用原DataFrame的'foo'列作为新DataFrame的index列，'bar'列的值作为新DataFrame的列名，'baz'列中与foo和bar对应的值为新DataFrame值。

3、cut

pandas.cut(
    x,
    bins,
    right=True,
    labels=None,
    retbins=False,
    precision=3,
    include_lowest=False,
    duplicates='raise',
    ordered=True
)

说明

切割一个一维数据为离散的区间，并自动为这些数据根据所在区间打标签。

参数

参数	类型	默认值	说明
x	一维的array或list
bins	int,int list		切割模式。 int：切割的块(也叫bin)数，每个bin的左右范围会比最小最大值扩展0.1%以容纳最大最小值（分割方式为等分，即用(max-min)/bins得到bin长） int list：切割bin的具体边界值，不扩展（此时区间数为len(list)-1）
right	bool	True	True表示bin为左开右闭区间；[1,2]表示(1,2]
labels	array或False	None	返回bin的对应label；必须和分出的bin等长 如果为False，则返回x的数据在第几个bin中
retbins	bool	False	是否返回bins（即参数2）
precision	int	3	在未指定labels时，默认bin区间的小数位数
include_lowest	bool	False	区间的左边是开还是闭

例子

给年龄分组

ages=[1,5,10,40,36,12,58,62,77,89,100,18,20,25,30,32]
 
pd.cut(ages, 5,labels=['婴儿','少年','青年','壮年','老年']) #划分为5个区间
[婴儿, 婴儿, 婴儿, 少年, 少年, ..., 婴儿, 婴儿, 少年, 少年, 少年]
Length: 16
Categories (5, object): [婴儿 < 少年 < 青年 < 壮年 < 老年]
 
pd.cut(ages, [0,5,18,30,45,100],labels=['婴儿','少年','青年','壮年','老年']) 
#划分为指定区间
[婴儿, 婴儿, 少年, 壮年, 壮年, ..., 少年, 青年, 青年, 青年, 壮年]
Length: 16
Categories (5, object): [婴儿 < 少年 < 青年 < 壮年 < 老年]

4、pandas.qcut

pandas.qcut(
    x,
    q,
    labels=None,
    retbins=False,
    precision=3,
)

说明

也是分割一个区间，分割方式为尽可能使每个bin中的元素数相等（cut的分割策略是使每个bin长度相等）

参数

参数	类型	说明
x	array、list、series（均一维）
q	int 或float list	int：bin数量 float list：指定分割点区间
labels	array或False	为分割区间指定label
precision	int	在未指定labels时，默认bin区间的小数位数

5、pandas.merge

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

说明

类似于数据库的两表连接

参数

参数	类型	说明
left	DataFrame	左DataFrame
right	DataFrame或Series	右DataFrame
how	{'left','right','outer','inner','cross'}	连接类型； left：只用左frame的keys，类似SQL的左外连接 right：右外连接 outer：外连接 innner：内连接 cross：笛卡尔积
on	label或list	参与连接的列label或索引List。 它们必须在两个DataFrame中均能找到。如果是None，则默认用两个DataFrame的同名列
left_on	label或list	参与连接的左边DataFrame的列label
right_on	label或list	参与连接的右边DataFrame的列label
left_index	bool	使用左边列的index作为连接键
right_index	bool	使用右边列的index作为连接键
sort	bool	是否对结果中的连接键进行排序。如果False，顺序取决于参数how指定的连接方式
suffixes	list-like	长为2的list，指定连接后左右属性列的附加后缀；比如('_x','_y')就说明连接后左边列的value为value_x，右边列的value为value_y

df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                    'value': [1, 2, 3, 5]})
df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'],
                    'value': [5, 6, 7, 8]})
df1
    lkey value
0   foo      1
1   bar      2
2   baz      3
3   foo      5
df2
    rkey value
0   foo      5
1   bar      6
2   baz      7
3   foo      8
 
df1.merge(df2, left_on='lkey', right_on='rkey')
  lkey  value_x rkey  value_y
0  foo        1  foo        5
1  foo        1  foo        8
2  foo        5  foo        5
3  foo        5  foo        8
4  bar        2  bar        6
5  baz        3  baz        7

6、pandas.merge_ordered

pandas.merge_ordered(
    left,
    right,
    how='outer',
    on=None,
    left_on=None,
    right_on=None,
    left_by=None,
    right_by=None,
    fill_method=None,
    suffixes=('_x', '_y')
)

说明

连接并按照某些列排序

参数

参数	类型	说明
left	DataFrame
right	DataFrame
how	{'left','right','outer','inner'}
on	同merge
left_on
rigth_on
left_by	列名或列名的list	合并后数据按照left_by指定的列排序
right_by	列名或列名的list	合并后数据按照right_by指定的列排序
fill_method	'ffill'或None	缺失值的填充方法
suffixes	同merge

例子

df1
      key  lvalue group
0   a       1     a
1   c       2     a
2   e       3     a
3   a       1     b
4   c       2     b
5   e       3     b
 
df2
      key  rvalue
0   b       1
1   c       2
2   d       3
 
merge_ordered(df1, df2, fill_method="ffill", left_by="group")#按'group'列排序
key  lvalue group  rvalue
0   a       1     a     NaN
1   b       1     a     1.0
2   c       2     a     2.0
……
8   d       2     b     3.0
9   e       3     b     3.0

7、pandas.merge_asof

pandas.merge_asof(
    left,
    right,
    on=None,
    left_on=None,
    right_on=None,
    left_index=False,
    right_index=False,
    by=None,
    left_by=None,
    right_by=None,
    suffixes=('_x', '_y'),
    tolerance=None,
    allow_exact_matches=True,
    direction='backward'
)

说明

连接，连接后根据前后（最临近）的值填充未知的值

参数

参数	类型	说明
left	DataFrame	参与连接的左DataFrame
right	DataFrame
on	label	参与连接的列名，左右DataFrame都有。该列数据必须是有序的；此外该列必须是数值列。要么声明参数On，要么同时声明left_on与right_on（左DataFrame中on列（或left_on列）的最大值必须大于右边对应列中的最大值）
left_on	label	参与连接的左DataFrame的列
rigth_on	label	参与连接的右DataFrame的列
left_index	bool	是否用左DataFrame的index列作为键
right_index	bool	是否用右DataFrame的index列作为键
by	列名或列名list	在连接前是否先对这些列进行匹配
left_by	列名	左DataFrame中的匹配列
right_by	列名	右DataFrame中的匹配列
suffixes	同merge
tolerance	int、timedelta	填充精度
allow_exact_matches	bool	是否给缺省值填充以临近值，否则填充以NaN
direction	backward、forward、nearest	上一个参数中的“临近”方向

这个函数我也没搞明白，如有需要可以参考官方文档：pandas.merge_asof，大概分析了下，对于涉及时间段的匹配和连接很有帮助。

8、concat

用法

pandas.concat(
    objs,
    axis=0,
    join='outer',
    ignore_index=False,
    names=None,
    verify_integrity=False,
    sort=False,
    copy=True
)

说明

连接series list中的series，指定连接维度；可以新建维度，比如把一维变二维、二维变三维

参数

参数	类型	默认值	说明
objs	Series或DataFrame的List、Tuple		参与连接的series的list
axis	0/'index' 、 1/'columns'	0	连接的维度 默认0，相当于A|B这种拼接方式
join	'inner'或'outer'	'outer'	如何处理另一个维度上的index
ignore_index	bool	False	True：不使用原index，而是代之以0,1,2...n-1 False：使用原index
names	list	None	结果objs中各列的名字
verify_integrity	bool	False	检查结果是否有重名列，如果为False且有重名列，会抛出ValueError
sort	bool	False	只在join='outer'起作用，对非连接的维度进行排序
copy	bool	True	是否复制不必要的数据

9、pandas.factorize

pandas.factorize(
    values,
    sort=False,
    na_sentinel=- 1
)

说明

返回两个array——codes和uniques，第二个是原list中的不重复的所有元素，第一个是原数组中的元素在第二个array中的索引下标

参数

参数	类型	说明
values	list、tupl、series（均是一维）	参与运算的序列
sort	bool	是否对uniques进行排序
na_sentinel	int或None	如何标记缺省值。如果是None，将会从uniques保留NaN

10、pandas.unique

pandas.unique(values)

说明

提取一个序列中的元素，不重复地保存到一个array中

参数

value：一维序列，list，tuple，series，array都可以

11、pandas.wide_to_long

pandas.wide_to_long(
    df,
    stubnames,
    i,
    j,
    sep='',
    suffix='\\d+'
)

说明

将属性行转换为数据列

参数

参数	类型	说明
df	DataFrame	待转化的宽DataFrame
stubnames	str或str list	该名字标识列名前缀，这些列名必须有相同的前缀，才能成功转化为行索引
i	str或str list	作为id的列的列名
j	str	接收原DataFrame第一行的列的列名
sep	str	原DataFrame中第一行的前缀与后缀间的连接符
suffix	str	正则表达式。转换后的长DataFrame的转换列的数据组织形式。

12、pandas.isna和pandas.isnull

pandas.isna(obj)

说明

检测一个obj（或其中的元素）是否为空值（这两种方法的用法相同）

例子

#单个值
pd.isna('dog')
False
pd.isna(pd.NA)
True
pd.isna(np.nan)
True
 
#数组
array = np.array([[1, np.nan, 3], [4, 5, np.nan]])
array
array([[ 1., nan,  3.],
       [ 4.,  5., nan]])
pd.isna(array)
array([[False,  True, False],
       [False, False,  True]])

13、pandas.notna和pandas.notnull

pandas.notna(obj)

说明

检查一个obj（或其中的元素）是否不是空值（与isna刚好相反）

例子

#单个值
pd.notna('dog')
True
pd.notna(pd.NA)
False
pd.notna(np.nan)
False
#数组
array = np.array([[1, np.nan, 3], [4, 5, np.nan]])
array
array([[ 1., nan,  3.],
       [ 4.,  5., nan]])
pd.notna(array)
array([[ True, False,  True],
       [ True,  True, False]])

14、pandas.to_numeric

pandas.to_numeric(arg, errors='raise', downcast=None)

说明

将一个序列中的元素全部数值化

参数

参数	类型	说明
arg	数值、list、tuple、一维array、series	待转化的数据
errors	{'ignore','raise','coerce'}	对无法转换的数据的处理 raise：抛出exception coerce：设为NaN ignore：忽略用原值填充
downcast	{'integer','signed','unsigned','float'}	转化后的数据会自动转化为该类型的最小大小类型，比如integer就会转化为np.int8

15、pandas.to_datetime

pandas.to_datetime(
    arg,
    errors='raise',
    dayfirst=False,
    yearfirst=False,
    utc=None,
    format=None,
    unit=None,
    infer_datetime_format=False,
    origin='unix',
)

说明

将数据转为datetime类型

参数

参数	类型	说明
arg	int、float、str、datetime、list、tuple、1-d array、series、DataFrame/dict	待转换的数据
errors	{'ignore','raise','coerce'}	对无法转换数据的处理：同上
dayfirst	bool	如果为True，说明输入的obj是以day开头的
yearfirst	bool	如果为True，说明输入的obj是以year开头的（如果和dayfirst均为True，则采用yearfirst）
utc	bool	返回结果为UTC时间戳
format	str	时间分解的格式化字符串，“%d/%m/%Y”则可以顺利分解出'12/2/2020'这种时间
unit	str(D、s、ms、us、ns)	单位，标注arg的单位（如果arg为数值型）
infer_datetime_format	bool	在没给出format时，该参数发挥作用，可自动推测str类型的arg的分解格式
origin	scalar	参考日期。

返回

datetime，返回类型取决于输入值：

输入值	返回值
list之类的	Datetime
数值	时间戳
Series	类型为datetime64的Series

16、pandas.to_timedelta

pandas.to_timedelta(arg, unit=None, errors='raise')

说明

将数据转化为Timedelta类型

参数

参数	类型	说明
arg	str、timedelta、list-like、Series
unit	str	参数arg的单位
errors	{'ignore','raise','coerce'}

返回：timedelta64或timedelta64 array

17、pandas.date_range

pandas.date_range(
    start=None,
    end=None,
    periods=None,
    freq=None,
    tz=None,
    normalize=False,
    name=None,
)

说明

以固定频率返回一个DatetimeIndex（给出日期的开头结尾或频率，返回在这之间的日期），其中包含若干Datetime

参数

参数	类型	说明
start	str或datetime-like（3/11/2000）	日期的开端
end	str或datetime-like	日期的结束
periods	int	日期数量
freq	ster或DateOffset	每次修改日期的哪个单位（年月日……）
tz	str	时区
name	bool	返回的DatetimeIndex的名字

18、pandas.bdate_range

说明：同17以固定频率返回一个DatetimeIndex，区别在于返回是工作日的日期

参数同上：区别在于是freq默认是'B'，即工作日

19、pandas.period_range

与17、18相同，区别在于①输入的是period-like（'2017-01-01'）；②返回PeriodIndex

20、pandas.timedelta_range

与17、19相同，区别在于①输入的是timedelta-like（'1 day'）；②返回TimedeltaIndex

21、pandas.interval_range

pandas.interval_range(
    start=None,
    end=None,
    periods=None,
    freq=None,
    name=None,
    closed='right'
)

说明：以固定频率返回IntervalIndex（与上边的区别在于这里是区间）

参数：

参数	类型	说明
start	数字或datetime	开端
end	数字或datetime	结尾
periods	int	分隔的区间数
freq	数字、str、DateOffset	区间长，必须与start和end类型相关
name	str	返回的IntervallIndex的名字
closed	{'left','right','both','neither'}	区间是否左右开闭

22、pandas.eval

pandas.eval(
    expr,
    parser='pandas',
    engine=None,
    target=None
)

说明：解析一个Python表达式的string，并用该表达式对某个Python类型的数据进行各种运算，返回运算后的结果

参数：

参数	类型	说明
expr	str	表达式string
parser	{‘pandas’, ‘python’}	建立语法树采用的解析器
engine	{‘python’, ‘numexpr’}	表达式运行的引擎
target	object	需要进行运算的Python数据

23、pandas.util.hash_array

pandas.util.hash_array(
    vals,
    encoding='utf8',
    hash_key='0123456789123456',
)

说明：对一个一维array进行hash加密

参数：

参数	类型	说明
vals	一维array	要加密的array，对array中的所有数据加密
encoding		编码方式
hash_key	str	用于加密的Hash_key

返回：类型为uint64的一维array

24、pandas.util.hash_pandas_object

说明：对一个（Index、Series、DataFrame）进行hash加密

参数：

参数	类型	说明
vals	Index、Series、DataFrame	要加密的array，对array中的所有数据加密
index	bool	是否包含index
其他同上

返回：类型为uint64的Series