Pandas中文官方文档之基础用法6.docx
《Pandas中文官方文档之基础用法6.docx》由会员分享，可在线阅读，更多相关《Pandas中文官方文档之基础用法6.docx（18页珍藏版）》请在冰豆网上搜索。
Pandas中文官方文档之基础用法6
数据类型
大多数情况下，pandas使用Numpy数组、Series或DataFrame里某列的数据类型。
Numpy支持 float、int、bool、timedelta[ns]、datetime64[ns]，注意，Numpy不支持带时区信息的 datetime。
Pandas与第三方支持库对Numpy类型系统进行了扩充，本节只介绍pandas的内部扩展。
如需了解自行编写与pandas配合的扩展类型，请参阅扩展类型，参阅扩展数据类型了解第三方支持库提供的扩展类型。
下表列出了pandas扩展类型，参阅列出的文档内容，查看每种类型的详情。
数据种类
数据类型
标量
数组
文档
带时区的
日期时间
DatetimeTZ
Timestamp
arrays.
DatetimeArray
Timezonehandling
类别型
Categorical
（无）
Categorical
Categoricaldata
时间段
Period
Period
arrays.
PeriodArray
Timespanrepresentation
稀疏数据
Sparse
（无）
arrays.
SparseArray
Sparsedatastructures
时间间隔
Interval
Interval
arrays.
IntervalArray
IntervalIndex
空整型
Int64...
（无）
arrays.
IntegerArray
Nullableintegerdatatype
此表要横屏看
Pandas用 object 存储字符串。
虽然， object 数据类型能够存储任何对象，但应尽量避免这种操作，要了解与其它支持库与方法的性能与交互操作，参阅对象转换。
DataFrame的 dtypes 属性用起来很方便，以Series形式返回每列的数据类型。
In [328]:
dft = pd.DataFrame（{'A':
np.random.rand（3）,
.....:
'B':
1,
.....:
'C':
'foo',
.....:
'D':
pd.Timestamp（'20010102'）,
.....:
'E':
pd.Series（[1.0] * 3）.astype（'float32'）,
.....:
'F':
False,
.....:
'G':
pd.Series（[1] * 3, dtype='int8'）}）
.....:
In [329]:
dft
Out[329]:
A B C D E F G
0 0.035962 1 foo 2001-01-02 1.0 False 1
1 0.701379 1 foo 2001-01-02 1.0 False 1
2 0.281885 1 foo 2001-01-02 1.0 False 1
In [330]:
dft.dtypes
Out[330]:
A float64
B int64
C object
D datetime64[ns]
E float32
F bool
G int8
dtype:
object
要查看 Series 的数据类型，用 dtype 属性。
In [331]:
dft['A'].dtype
Out[331]:
dtype（'float64'）
Pandas对象单列中含多种类型的数据时，该列的数据类型为可适配于各类数据的数据类型，通常为 object。
# 整数被强制转换为浮点数
In [332]:
pd.Series（[1, 2, 3, 4, 5, 6.]）
Out[332]:
0 1.0
1 2.0
2 3.0
3 4.0
4 5.0
5 6.0
dtype:
float64
# 字符串数据决定了该 Series 的数据类型为 ``object``
In [333]:
pd.Series（[1, 2, 3, 6., 'foo']）
Out[333]:
0 1
1 2
2 3
3 6
4 foo
dtype:
object
DataFrame.dtypes.value_counts（） 用于统计DataFrame里各列数据类型的数量。
In [334]:
dft.dtypes.value_counts（）
Out[334]:
float32 1
object 1
bool 1
int8 1
float64 1
datetime64[ns] 1
int64 1
dtype:
int64
多种数值型数据类型可以在DataFrame里共存。
如果只传递一种数据类型，不论是通过 dtype关键字直接传递，还是通过 ndarray 或 Series 传递，都会保存至DataFrame操作。
此外，不同数值型数据类型不会合并。
示例如下：
In [335]:
df1 = pd.DataFrame（np.random.randn（8, 1）, columns=['A'], dtype='float32'）
In [336]:
df1
Out[336]:
A
0 0.224364
1 1.890546
2 0.182879
3 0.787847
4 -0.188449
5 0.667715
6 -0.011736
7 -0.399073
In [337]:
df1.dtypes
Out[337]:
A float32
dtype:
object
In [338]:
df2 = pd.DataFrame（{'A':
pd.Series（np.random.randn（8）, dtype='float16'）,
.....:
'B':
pd.Series（np.random.randn（8））,
.....:
'C':
pd.Series（np.array（np.random.randn（8）,
.....:
dtype='uint8'））}）
.....:
In [339]:
df2
Out[339]:
A B C
0 0.823242 0.256090 0
1 1.607422 1.426469 0
2 -0.333740 -0.416203 255
3 -0.063477 1.139976 0
4 -1.014648 -1.193477 0
5 0.678711 0.096706 0
6 -0.040863 -1.956850 1
7 -0.357422 -0.714337 0
In [340]:
df2.dtypes
Out[340]:
A float16
B float64
C uint8
dtype:
object
默认值
整数的默认类型为 int64，浮点数的默认类型为 float64，这里的默认值与系统平台无关，不管是32位系统，还是64位系统都是一样的。
下列代码返回的结果都是 int64：
In [341]:
pd.DataFrame（[1, 2], columns=['a']）.dtypes
Out[341]:
a int64
dtype:
object
In [342]:
pd.DataFrame（{'a':
[1, 2]}）.dtypes
Out[342]:
a int64
dtype:
object
In [343]:
pd.DataFrame（{'a':
1}, index=list（range
（2）））.dtypes
Out[343]:
a int64
dtype:
object
注意，Numpy创建数组时，会根据系统选择类型。
下列代码在32位系统上将返回 int32。
In [344]:
frame = pd.DataFrame（np.array（[1, 2]））
向上转型
与其它类型合并时，要用到向上转型，这里指的是从现有类型转换为另一种类型，如int 变为float。
In [345]:
df3 = df1.reindex_like（df2）.fillna（value=0.0） + df2
In [346]:
df3
Out[346]:
A B C
0 1.047606 0.256090 0.0
1 3.497968 1.426469 0.0
2 -0.150862 -0.416203 255.0
3 0.724370 1.139976 0.0
4 -1.203098 -1.193477 0.0
5 1.346426 0.096706 0.0
6 -0.052599 -1.956850 1.0
7 -0.756495 -0.714337 0.0
In [347]:
df3.dtypes
Out[347]:
A float32
B float64
C float64
dtype:
object
DataFrame.to_numpy（） 返回多个数据类型里用的最多的数据类型，这里指的是输出结果的数据类型是适用于所有同质Numpy数组的数据类型。
这里会强制执行向上转型。
In [348]:
df3.to_numpy（）.dtype
Out[348]:
dtype（'float64'）
astype
astype（） 方法显式地把一种数据类型转换为另一种，默认返回的是复制数据，就算数据类型没有改变也会执行复制操作，copy=False 可以改变默认操作模式。
此外，如果 astype 无效会触发异常。
向上转型一般都会遵循 numpy 的规则。
如果操作中涉及两种不同类型的数据，返回的将是更通用的那种数据类型。
In [349]:
df3
Out[349]:
A B C
0 1.047606 0.256090 0.0
1 3.497968 1.426469 0.0
2 -0.150862 -0.416203 255.0
3 0.724370 1.139976 0.0
4 -1.203098 -1.193477 0.0
5 1.346426 0.096706 0.0
6 -0.052599 -1.956850 1.0
7 -0.756495 -0.714337 0.0
In [350]:
df3.dtypes
Out[350]:
A float32
B float64
C float64
dtype:
object
# 转换数据类型
In [351]:
df3.astype（'float32'）.dtypes
Out[351]:
A float32
B float32
C float32
dtype:
object
用 astype（） 把一列或多列转换为指定类型。
In [352]:
dft = pd.DataFrame（{'a':
[1, 2, 3], 'b':
[4, 5, 6], 'c':
[7, 8, 9]}）
In [353]:
dft[['a', 'b']] = dft[['a', 'b']].astype（np.uint8）
In [354]:
dft
Out[354]:
a b c
0 1 4 7
1 2 5 8
2 3 6 9
In [355]:
dft.dtypes
Out[355]:
a uint8
b uint8
c int64
dtype:
object
0.19.0版新增。
astype（） 通过字典指定哪些列转换为哪些类型。
In [356]:
dft1 = pd.DataFrame（{'a':
[1, 0, 1], 'b':
[4, 5, 6], 'c':
[7, 8, 9]}）
In [357]:
dft1 = dft1.astype（{'a':
np.bool, 'c':
np.float64}）
In [358]:
dft1
Out[358]:
a b c
0 True 4 7.0
1 False 5 8.0
2 True 6 9.0
In [359]:
dft1.dtypes
Out[359]:
a bool
b int64
c float64
dtype:
object
用 astype（） 与 loc（） 为部分列转换指定类型时，会发生向上转型。
loc（） 尝试分配当前的数据类型，而 [] 则会从右方获取数据类型并进行覆盖。
因此，下列代码会产出意料之外的结果：
In [360]:
dft = pd.DataFrame（{'a':
[1, 2, 3], 'b':
[4, 5, 6], 'c':
[7, 8, 9]}）
In [361]:
dft.loc[:
['a', 'b']].astype（np.uint8）.dtypes
Out[361]:
a uint8
b uint8
dtype:
object
In [362]:
dft.loc[:
['a', 'b']] = dft.loc[:
['a', 'b']].astype（np.uint8）
In [363]:
dft.dtypes
Out[363]:
a int64
b int64
c int64
dtype:
object
对象转换
Pandas提供了多种函数可以把 object 从一种类型强制转为另一种类型。
这是因为，数据有时存储的是正确类型，但在保存时却存成了 object 类型，此时，用DataFrame.infer_objects（） 与 Series.infer_objects（） 方法即可把数据软转换为正确的类型。
In [364]:
import datetime
In [365]:
df = pd.DataFrame（[[1, 2],
.....:
['a', 'b'],
.....:
[datetime.datetime（2016, 3, 2）,
.....:
datetime.datetime（2016, 3, 2）]]）
.....:
In [366]:
df = df.T
In [367]:
df
Out[367]:
0 1 2
0 1 a 2016-03-02
1 2 b 2016-03-02
In [368]:
df.dtypes
Out[368]:
0 object
1 object
2 datetime64[ns]
dtype:
object
因为数据被转置，所以把原始列的数据类型改成了 object，但使用 infer_objects 后就变正确了。
In [369]:
df.infer_objects（）.dtypes
Out[369]:
0 int64
1 object
2 datetime64[ns]
dtype:
object
下列函数可以应用于一维数组与标量，执行硬转换，把对象转换为指定类型。
∙`to_numeric（）`，转换为数值型
In [370]:
m = ['1.1', 2, 3]
In [371]:
pd.to_numeric（m）
Out[371]:
array（[1.1, 2. , 3. ]）
∙`to_datetime（）`，转换为 datetime 对象
In [372]:
import datetime
In [373]:
m = ['2016-07-09', datetime.datetime（2016, 3, 2）]
In [374]:
pd.to_datetime（m）
Out[374]:
DatetimeIndex（['2016-07-09', '2016-03-02'], dtype='datetime64[ns]', freq=None）
∙`to_timedelta（）`，转换为 timedelta 对象。
In [375]:
m = ['5us', pd.Timedelta（'1day'）]
In [376]:
pd.to_timedelta（m）
Out[376]:
TimedeltaIndex（['0 days 00:
00:
00.000005', '1 days 00:
00:
00'], dtype='timedelta64[ns]', freq=None）
如需强制转换，则要加入 error 参数，指定pandas怎样处理不能转换为成预期类型或对象的数据。
errors 参数的默认值为 False，指的是在转换过程中，遇到任何问题都触发错误。
设置为 errors='coerce' 时，pandas会忽略错误，强制把问题数据转换为 pd.NaT（datetime与 timedelta），或 np.nan（数值型）。
读取数据时，如果大部分要转换的数据是数值型或datetime，这种操作非常有用，但偶尔也会有非制式数据混合在一起，可能会导致展示数据缺失：
In [377]:
import datetime
In [378]:
m = ['apple', datetime.datetime（2016, 3, 2）]
In [379]:
pd.to_datetime（m, errors='coerce'）
Out[379]:
DatetimeIndex（['NaT', '2016-03-02'], dtype='datetime64[ns]', freq=None）
In [380]:
m = ['apple', 2, 3]
In [381]:
pd.to_numeric（m, errors='coerce'）
Out[381]:
array（[nan, 2., 3.]）
In [382]:
m = ['apple', pd.Timedelta（'1day'）]
In [383]:
pd.to_timedelta（m, errors='coerce'）
Out[383]:
TimedeltaIndex（[NaT, '1 days'], dtype='timedelta64[ns]', freq=None）
error 参数还有第三个选项，error='ignore'。
转换数据时会忽略错误，直接输出问题数据：
In [384]:
import datetime
In [385]:
m = ['apple', datetime.datetime（2016, 3, 2）]
In [386]:
pd.to_datetime（m, errors='ignore'）
Out[386]:
Index（['apple', 2016-03-02 00:
00:
00], dtype='object'）
In [387]:
m = ['apple', 2, 3]
In [388]:
pd.to_numeric（m, errors='ignore'）
Out[388]:
array（['apple', 2, 3], dtype=object）
In [389]:
m = ['apple', pd.Timedelta（'1day'）]
In [390]:
pd.to_timedelta（m, errors='ignore'）
Out[390]:
array（['apple', Timedelta（'1 days 00:
00:
00'）], dtype=object）
执行转换操作时，to_numeric（） 还有一个参数，downcast，即向下转型，可以把数值型转换为减少内存占用的数据类型：
In [391]:
m = ['1', 2, 3]
In [392]:
pd.to_numeric（m, downcast='integer'） # smallest signed int dtype
Out[392]:
array（[1, 2, 3], dtype=int8）
In [393]:
pd.to_numeric（m, downcast='signed'） # same as 'integer'
Out[393]:
array（[1, 2, 3], dtype=int8）
In [394]:
pd.to_numeric（m, downcast='unsigned'） # smallest unsigned int dtype
Out[394]:
array（[1, 2, 3], dtype=uint8）
In [395]:
pd.to_numeric（m, downcast='float'） # smallest float dtype
Out[395]:
array（[1., 2., 3.], dtype=float32）
上述方法仅能应用于一维数组、列表或标量；不能直接用于DataFrame等多维对象。
不过，用apply（），可以快速为每列应用函数：
In [396]:
import datetime
In [397]:
df = pd.DataFrame（[
.....:
升级会员 