Python：pandas（二）—

空值：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	检测一个obj（或其中的元素）是否为空值（这两种方法的用法相同）
notna	检查一个obj（或其中的元素）是否不是空值（与isna刚好相反）
notnull	检查一个obj（或其中的元素）是否不是空值（与isna刚好相反）
转换
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

巴特西

Python：pandas（二）——pandas函数