【12月DW打卡】joyful-pandas - Task09：类别类型数据（categories/cat对象、有序分类、区间类别）

2024-04-08 19:06:46

第九章 pandas 类别型数据(categories)

小结

原文指路：(joyful-pandas)[https://datawhalechina.github.io/joyful-pandas/build/html/目录/ch9.html#cat]
jupyter nbconvert --to markdown E:\PycharmProjects\TianChiProject\00_山枫叶纷飞\competitions\09_pandas类别型数据.ipynb

纠错

在二、有序分类的1. 序的建立中出现无需类别错别字，应为有序类别。地址：https://datawhalechina.github.io/joyful-pandas/build/html/目录/ch9.html

import numpy as np
import pandas as pd
pd.__version__

'1.2.0'

file_prefix = 'E:\\PycharmProjects\\DatawhaleChina\\joyful-pandas\\data\\'
print(file_prefix)

E:\PycharmProjects\DatawhaleChina\joyful-pandas\data\

一、cat对象

1. cat对象的属性

在 pandas 中提供了 category 类型，使用户能够处理分类类型的变量，将一个普通序列转换成分类变量可以使用 astype 方法。

df = pd.read_csv(file_prefix+'learn_pandas.csv', usecols = ['Grade', 'Name', 'Gender', 'Height', 'Weight'])

s = df.Grade.astype('category')

s.head()

0     Freshman
1     Freshman
2       Senior
3    Sophomore
4    Sophomore
Name: Grade, dtype: category
Categories (4, object): ['Freshman', 'Junior', 'Senior', 'Sophomore']

在一个分类类型的 Series 中定义了 cat 对象，它和上一章中介绍的 str 对象类似，定义了一些属性和方法来进行分类类别的操作。
对于一个具体的分类，有两个组成部分，其一为类别的本身，它以 Index 类型存储，其二为是否有序，它们都可以通过 cat 的属性被访问：

s.cat.categories

Index(['Freshman', 'Junior', 'Senior', 'Sophomore'], dtype='object')

s.cat.ordered

False

另外，每一个序列的类别会被赋予唯一的整数编号，它们的编号取决于 cat.categories 中的顺序，该属性可以通过 codes 访问：

s.cat.codes.head()

0    0
1    0
2    2
3    3
4    3
dtype: int8

2. 类别类型的增加、删除和修改

类别不得直接修改

在第三章中曾提到，索引 Index 类型是无法用 index_obj[0] = item 来修改的，而 categories 被存储在 Index 中，因此 pandas 在 cat 属性上定义了若干方法来达到相同的目的。

# 首先，对于类别的增加可以使用 add_categories ：
# 示例： 增加一个毕业生类别

s.cat.add_categories('Graduate')

0       Freshman
1       Freshman
2         Senior
3      Sophomore
4      Sophomore
         ...    
195       Junior
196       Senior
197       Senior
198       Senior
199    Sophomore
Name: Grade, Length: 200, dtype: category
Categories (5, object): ['Freshman', 'Junior', 'Senior', 'Sophomore', 'Graduate']

若要删除某一个类别可以使用 remove_categories ，同时所有原来序列中的该类会被设置为缺失。例如，删除大一的类别：

s.cat.remove_categories('Freshman')

0            NaN
1            NaN
2         Senior
3      Sophomore
4      Sophomore
         ...    
195       Junior
196       Senior
197       Senior
198       Senior
199    Sophomore
Name: Grade, Length: 200, dtype: category
Categories (3, object): ['Junior', 'Senior', 'Sophomore']

此外可以使用 set_categories 直接设置序列的新类别，原来的类别中如果存在元素不属于新类别，那么会被设置为缺失。

s.cat.set_categories(['Sophomore','PhD']) # 新类别为大二学生和博士

0            NaN
1            NaN
2            NaN
3      Sophomore
4      Sophomore
         ...    
195          NaN
196          NaN
197          NaN
198          NaN
199    Sophomore
Name: Grade, Length: 200, dtype: category
Categories (2, object): ['Sophomore', 'PhD']

如果想要删除未出现在序列中的类别，可以使用 remove_unused_categories 来实现：

s = s.cat.remove_unused_categories() # 移除了未出现的博士生类别
s

0       Freshman
1       Freshman
2         Senior
3      Sophomore
4      Sophomore
         ...    
195       Junior
196       Senior
197       Senior
198       Senior
199    Sophomore
Name: Grade, Length: 200, dtype: category
Categories (4, object): ['Freshman', 'Junior', 'Senior', 'Sophomore']

s.cat.rename_categories({'Sophomore':'本科二年级学生'})

0      Freshman
1      Freshman
2        Senior
3       本科二年级学生
4       本科二年级学生
         ...   
195      Junior
196      Senior
197      Senior
198      Senior
199     本科二年级学生
Name: Grade, Length: 200, dtype: category
Categories (4, object): ['Freshman', 'Junior', 'Senior', '本科二年级学生']

有序的分类类型

有序类别和无序类别可以通过 as_unordered 和 reorder_categories 互相转化，需要注意的是后者传入的参数必须是由当前序列的无序类别构成的列表，不能够增加新的类别，也不能缺少原来的类别，并且必须指定参数 ordered=True ，否则方法无效。例如，对年级高低进行相对大小的类别划分，然后再恢复无序状态：

s = df.Grade.astype('category')
print('有序化：')
s_order = s.cat.reorder_categories(['Freshman', 'Sophomore',                              'Junior', 'Senior'], ordered=True)
s_order

有序化：





0       Freshman
1       Freshman
2         Senior
3      Sophomore
4      Sophomore
         ...    
195       Junior
196       Senior
197       Senior
198       Senior
199    Sophomore
Name: Grade, Length: 200, dtype: category
Categories (4, object): ['Freshman', 'Sophomore', 'Junior', 'Senior']

print('可以先用 s.cat.as_ordered() 转化为有序类别')
s_order2 = s.cat.as_ordered()
s_order2 = s_order2.cat.reorder_categories(['Freshman', 'Sophomore',                              'Junior', 'Senior'] )
s_order2

可以先用 s.cat.as_ordered() 转化为有序类别





0       Freshman
1       Freshman
2         Senior
3      Sophomore
4      Sophomore
         ...    
195       Junior
196       Senior
197       Senior
198       Senior
199    Sophomore
Name: Grade, Length: 200, dtype: category
Categories (4, object): ['Freshman' < 'Sophomore' < 'Junior' < 'Senior']

print('无序化：')
s_unorder = s.cat.as_unordered()
s_unorder

无序化：





0       Freshman
1       Freshman
2         Senior
3      Sophomore
4      Sophomore
         ...    
195       Junior
196       Senior
197       Senior
198       Senior
199    Sophomore
Name: Grade, Length: 200, dtype: category
Categories (4, object): ['Freshman', 'Junior', 'Senior', 'Sophomore']

2. 排序和比较

在第二章中，曾提到了字符串和数值类型序列的排序，此时就要说明分类变量的排序：只需把列的类型修改为 category 后，再赋予相应的大小关系，就能正常地使用 sort_index 和 sort_values 。例如，对年级进行排序：

df.Grade = df.Grade.astype('category')
df.Grade = df.Grade.cat.reorder_categories(['Freshman', 'Sophomore',                              'Junior', 'Senior'], ordered=True)

df.sort_values('Grade').head() # 值排序

	Grade	Name	Gender	Height	Weight
0	Freshman	Gaopeng Yang	Female	158.9	46.0
105	Freshman	Qiang Shi	Female	164.5	52.0
96	Freshman	Changmei Feng	Female	163.8	56.0
88	Freshman	Xiaopeng Han	Female	164.1	53.0
81	Freshman	Yanli Zhang	Female	165.1	52.0

df.set_index('Grade').sort_index().head() # 索引排序

	Name	Gender	Height	Weight
Grade
Freshman	Gaopeng Yang	Female	158.9	46.0
Freshman	Qiang Shi	Female	164.5	52.0
Freshman	Changmei Feng	Female	163.8	56.0
Freshman	Xiaopeng Han	Female	164.1	53.0
Freshman	Yanli Zhang	Female	165.1	52.0

由于序的建立，因此就可以进行比较操作。

分类变量的比较操作分为两类，第一种是 == 或 != 关系的比较，比较的对象可以是标量或者同长度的 Series （或 list ），第二种是 >,>=,<,<= 四类大小关系的比较，比较的对象和第一种类似，但是所有参与比较的元素必须属于原序列的 categories ，同时要和原序列具有相同的索引。

# 测试相等
(df.Grade == 'Sophomore').head()

0    False
1    False
2    False
3     True
4     True
Name: Grade, dtype: bool

# 测试小于
( df.Grade <= 'Sophomore').head()

0     True
1     True
2    False
3     True
4     True
Name: Grade, dtype: bool

三、区间类别

1. 利用cut和qcut进行区间构造

pd.cut的说明

最重要的参数是 bin ，如果传入整数 n ，则代表把整个传入数组的按照最大和最小值等间距地分为 n 段
由于区间默认是左开右闭，需要进行调整把最小值包含进去，在 pandas 中的解决方案是在值最小的区间左端点再减去 0.001*(max-min) ，因此如果对序列 [1,2] 划分为2个箱子时，第一个箱子的范围 (0.999,1.5] ，第二个箱子的范围是 (1.5,2] 。
如果需要指定左闭右开时，需要把 right 参数设置为 False ，相应的区间调整方法是在值最大的区间右端点再加上 0.001*(max-min) 。

s = pd.Series([1,2])
pd.cut(s, bins=2)

0    (0.999, 1.5]
1      (1.5, 2.0]
dtype: category
Categories (2, interval[float64]): [(0.999, 1.5] < (1.5, 2.0]]

print('设置左开右开')
pd.cut(s, bins=2, right=False)

设置左开右开





0      [1.0, 1.5)
1    [1.5, 2.001)
dtype: category
Categories (2, interval[float64]): [[1.0, 1.5) < [1.5, 2.001)]

bins 的另一个常见用法是指定区间分割点的列表（使用 np.infty 可以表示无穷大）

pd.cut(s, bins=[-np.infty, 1.2, 1.8, 2.2, np.infty])

0    (-inf, 1.2]
1     (1.8, 2.2]
dtype: category
Categories (4, interval[float64]): [(-inf, 1.2] < (1.2, 1.8] < (1.8, 2.2] < (2.2, inf]]

另外两个常用参数为 labels 和 retbins ，分别代表了区间的名字和是否返回分割点（默认不返回）：
返回时，返回一个元组

pd.cut(s, bins=2, labels=['small', 'big'], retbins=True)

(0    small
 1      big
 dtype: category
 Categories (2, object): ['small' < 'big'], array([0.999, 1.5  , 2.   ]))

分位数分箱qcut

cut 和 cut 几乎没有差别，只是把 bins 参数变成的 q 参数， qcut 中的 q 是指 quantile 。
这里的 q 为整数 n 时，指按照 n 等分位数把数据分箱，还可以传入浮点列表指代相应的分位数分割点。

pd.qcut(df.Weight, q=3).head()

0    (33.999, 48.0]
1      (55.0, 89.0]
2      (55.0, 89.0]
3    (33.999, 48.0]
4      (55.0, 89.0]
Name: Weight, dtype: category
Categories (3, interval[float64]): [(33.999, 48.0] < (48.0, 55.0] < (55.0, 89.0]]

pd.qcut(df.Weight, q=[0,0.2,0.8,1]).head()

0      (44.0, 69.4]
1      (69.4, 89.0]
2      (69.4, 89.0]
3    (33.999, 44.0]
4      (69.4, 89.0]
Name: Weight, dtype: category
Categories (3, interval[float64]): [(33.999, 44.0] < (44.0, 69.4] < (69.4, 89.0]]

2. 一般区间的构造（ pd.Interval(）对象和IntervalIndex（））

对于某一个具体的区间而言，其具备三个要素，即左端点、右端点和端点的开闭状态，其中开闭状态可以指定 right, left, both, neither 中的一类（指定的一端为闭合）：

my_interval = pd.Interval(0, 1, 'right')
my_interval

Interval(0, 1, closed='right')

pd.Interval(）对象其属性包含了 mid, length, right, left, closed ，分别表示中点、长度、右端点、左端点和开闭状态。
使用 in 可以判断元素是否属于区间：

0.5 in my_interval

True

使用 overlaps 可以判断两个区间是否有交集：

my_interval_2 = pd.Interval(0.5, 1.5, 'left')
my_interval.overlaps(my_interval_2)

True

一般而言， pd.IntervalIndex 对象有四类方法生成，分别是 from_breaks, from_arrays, from_tuples, interval_range ，它们分别应用于不同的情况：

from_breaks 的功能类似于 cut 或 qcut 函数，只不过后两个是通过计算得到的风格点，而前者是直接传入自定义的分割点：

pd.IntervalIndex.from_breaks([1,3,6,10], closed='both')

IntervalIndex([[1, 3], [3, 6], [6, 10]],
              closed='both',
              dtype='interval[int64]')

from_arrays 是分别传入左端点和右端点的列表，适用于有交集并且知道起点和终点的情况：

pd.IntervalIndex.from_arrays(left = [1,3,6,10],
right = [5,4,9,11],
closed = 'neither')

IntervalIndex([(1, 5), (3, 4), (6, 9), (10, 11)],
              closed='neither',
              dtype='interval[int64]')

from_tuples 传入的是起点和终点元组构成的列表：

pd.IntervalIndex.from_tuples([(1,5),(3,4),(6,9),(10,11)],closed='neither')

IntervalIndex([(1, 5), (3, 4), (6, 9), (10, 11)],
              closed='neither',
              dtype='interval[int64]')

一个等差的区间序列由起点、终点、区间个数和区间长度决定，其中三个量确定的情况下，剩下一个量就确定了， interval_range 中的 start, end, periods, freq 参数就对应了这四个量，从而就能构造出相应的区间：
(四个参数全填并且填不对的话，会报错！)

# periods表示区间个数
pd.interval_range(start=1,end=5,periods=8)

IntervalIndex([(1.0, 1.5], (1.5, 2.0], (2.0, 2.5], (2.5, 3.0], (3.0, 3.5], (3.5, 4.0], (4.0, 4.5], (4.5, 5.0]],
              closed='right',
              dtype='interval[float64]')

# freq（单个区间的频率，区间长度）
pd.interval_range(end=5,periods=8,freq=0.5)

IntervalIndex([(1.0, 1.5], (1.5, 2.0], (2.0, 2.5], (2.5, 3.0], (3.0, 3.5], (3.5, 4.0], (4.0, 4.5], (4.5, 5.0]],
              closed='right',
              dtype='interval[float64]')

练一练

无论是 interval_range 还是下一章时间序列中的 date_range 都是给定了等差序列中四要素中的三个，从而确定整个序列。请回顾等差数列中的首项、末项、项数和公差的联系，写出 interval_range 中四个参数之间的恒等关系。

等差数列式子： an=a1+(n-1)*d

end = start + (periods) * freq

除此之外，如果直接使用 pd.IntervalIndex([...], closed=...) ，把 Interval 类型的列表组成传入其中转为区间索引，那么所有的区间会被强制转为指定的 closed 类型，因为 pd.IntervalIndex 只允许存放同一种开闭区间的 Interval 对象。

pd.IntervalIndex([my_interval, my_interval_2], closed='left')

IntervalIndex([[0.0, 1.0), [0.5, 1.5)],
              closed='left',
              dtype='interval[float64]')

3. 区间的属性与方法(IntervalIndex)

IntervalIndex 上也定义了一些有用的属性和方法。同时，如果想要具体利用 cut 或者 qcut 的结果进行分析，那么需要先将其转为该种索引类型：

id_interval = pd.IntervalIndex(pd.cut(s, 3))
id_interval

IntervalIndex([(0.999, 1.333], (1.667, 2.0]],
              closed='right',
              dtype='interval[float64]')

与单个 Interval 类型相似， IntervalIndex 有若干常用属性： left, right, mid, length ，分别表示左右端点、两端点均值和区间长度。

IntervalIndex 还有两个常用方法，包括 contains 和 overlaps ，分别指逐个判断每个区间是否包含某元素，以及是否和一个 pd.Interval 对象有交集。

id_interval.contains(4)

array([False, False])

id_interval.overlaps(pd.Interval(40,60))

array([False, False])

四、练习

Ex1：统计未出现的类别

在第五章中介绍了crosstab函数，在默认参数下它能够对两个列的组合出现的频数进行统计汇总：

df = pd.DataFrame({'A':['a','b','c','a'], 'B':['cat','cat','dog','cat']})
pd.crosstab(df.A, df.B)

B	cat	dog
A
a	2	0
b	1	0
c	0	1

但事实上有些列存储的是分类变量，列中并不一定包含所有的类别，此时如果想要对这些未出现的类别在crosstab结果中也进行汇总，则可以指定dropna参数为False：

df.B = df.B.astype('category').cat.add_categories('sheep')
pd.crosstab(df.A, df.B, dropna=False)

B	cat	dog	sheep
A
a	2	0	0
b	1	0	0
c	0	1	0

请实现一个带有dropna参数的my_crosstab函数来完成上面的功能。

"""
解析答案的思路:
1. 找出各自的类别种类集合
2. 各自累加
"""
def my_crosstab(s1, s2, dropna=True):
    idx1 = (s1.cat.categories if s1.dtype.name == 'category' and  not dropna else s1.unique())
    idx2 = (s2.cat.categories if s2.dtype.name == 'category' and  not dropna else s2.unique())
    res = pd.DataFrame(np.zeros((idx1.shape[0], idx2.shape[0])), index=idx1, columns=idx2)
    for i, j in zip(s1, s2):
        res.at[i, j] += 1
    res = res.rename_axis(index=s1.name, columns=s2.name).astype('int')
    return res

# 测试
my_crosstab(df.A, df.B, dropna=False)

B	cat	dog	sheep
A
a	2	0	0
b	1	0	0
c	0	1	0

Ex2：钻石数据集

现有一份关于钻石的数据集，其中carat, cut, clarity, price分别表示克拉重量、切割质量、纯净度和价格，样例如下：

df = pd.read_csv(file_prefix + 'diamonds.csv')
df.head(3)

	carat	cut	clarity	price
0	0.23	Ideal	SI2	326
1	0.21	Premium	SI1	326
2	0.23	Good	VS1	327

分别对df.cut在object类型和category类型下使用nunique函数，并比较它们的性能。

%timeit -n 30 df.astype('object').nunique()

20 ms ± 888 µs per loop (mean ± std. dev. of 7 runs, 30 loops each)

%timeit -n 30 df.astype('category').nunique()

10.8 ms ± 769 µs per loop (mean ± std. dev. of 7 runs, 30 loops each)

print('显而易见,category更快一些 ')

钻石的
切割质量可以分为五个等级，由次到好分别是Fair, Good, Very Good, Premium, Ideal，
纯净度有八个等级，由次到好分别是I1, SI2, SI1, VS2, VS1, VVS2, VVS1, IF，

请对切割质量按照由好到次的顺序排序，相同切割质量的钻石，按照纯净度进行由次到好的排序。

df['cut'] = df['cut'].astype('category').cat.reorder_categories(['Fair', 'Good', 'Very Good', 'Premium', 'Ideal'],ordered=True)
df.clarity = df.clarity.astype('category').cat.reorder_categories([
     'I1', 'SI2', 'SI1', 'VS2', 'VS1', 'VVS2', 'VVS1', 'IF'],ordered=True)

print('排序:')
df.sort_values(['cut', 'clarity'], ascending=[False, True])

排序:

	carat	cut	clarity	price
315	0.96	Ideal	I1	2801
535	0.96	Ideal	I1	2826
551	0.97	Ideal	I1	2830
653	1.01	Ideal	I1	2844
718	0.97	Ideal	I1	2856
...	...	...	...	...
41242	0.30	Fair	IF	1208
43778	0.37	Fair	IF	1440
47407	0.52	Fair	IF	1849
49683	0.52	Fair	IF	2144
50126	0.47	Fair	IF	2211

53940 rows × 4 columns

分别采用两种不同的方法，把cut, clarity这两列按照由好到次的顺序，映射到从0到n-1的整数，其中n表示类别的个数。

print('使用cat.codes映射索引')
df_copy = df.copy()
for name in ['cut', 'clarity']:
    df_copy[name] = df[name].astype('category').cat.codes

df_copy.head()

cut方法

	carat	cut	clarity	price
0	0.23	4	1	326
1	0.21	3	2	326
2	0.23	1	4	327
3	0.29	3	3	334
4	0.31	1	1	335

print('replace一个字典大发~~')
df_copy2 = df.copy()
for name in ['cut', 'clarity']:
    cat_cats = df[name].cat.categories
    df_copy2[name] = df[name].replace(
        dict(zip(cat_cats, np.arange(len(cat_cats))))
        )
df_copy2.head()

qcut方法

	carat	cut	clarity	price
0	0.23	4	1	326
1	0.21	3	2	326
2	0.23	1	4	327
3	0.29	3	3	334
4	0.31	1	1	335

对每克拉的价格按照分别按照分位数（q=[0.2, 0.4, 0.6, 0.8]）与[1000, 3500, 5500, 18000]割点进行分箱得到五个类别Very Low, Low, Mid, High, Very High，并把按这两种分箱方法得到的category序列依次添加到原表中。

print('对每克拉的价格按照分位数（q=\[0.2, 0.4, 0.6, 0.8\]）处理:')
q = [0, 0.2, 0.4, 0.6, 0.8, 1]
avg_price = df.price / df.carat
df['new_qcut'] = pd.qcut(avg_price, q=q, labels=['Very Low', 'Low', 'Mid', 'High', 'Very High'])

print('对每克拉的价格按照\[1000, 3500, 5500, 18000\]割点进行分箱:')
df['new_cut'] = pd.cut(avg_price, bins=[-np.infty, 1000, 3500, 5500, 18000, np.infty], labels=['Very Low', 'Low', 'Mid', 'High', 'Very High'])
df

对每克拉的价格按照分位数（q=\[0.2, 0.4, 0.6, 0.8\]）处理:
对每克拉的价格按照\[1000, 3500, 5500, 18000\]割点进行分箱:

	carat	cut	clarity	price	new_qcut	new_cut
0	0.23	Ideal	SI2	326	Very Low	Low
1	0.21	Premium	SI1	326	Very Low	Low
2	0.23	Good	VS1	327	Very Low	Low
3	0.29	Premium	VS2	334	Very Low	Low
4	0.31	Good	SI2	335	Very Low	Low
...	...	...	...	...	...	...
53935	0.72	Ideal	SI1	2757	Mid	Mid
53936	0.72	Good	SI1	2757	Mid	Mid
53937	0.70	Very Good	SI1	2757	Mid	Mid
53938	0.86	Premium	SI2	2757	Mid	Low
53939	0.75	Ideal	SI2	2757	Mid	Mid

53940 rows × 6 columns

第4问中按照整数分箱得到的序列中，是否出现了所有的类别？如果存在没有出现的类别请把该类别删除。

df['new_cut'].unique()

['Low', 'Mid', 'High']
Categories (3, object): ['Low' < 'Mid' < 'High']

print('以下类别部分没有出现过:')
df.new_cut.cat.categories

以下类别没有出现过:





Index(['Very Low', 'Low', 'Mid', 'High', 'Very High'], dtype='object')

df.new_cut.cat.remove_categories(['Very Low', 'Very High'])

0        Low
1        Low
2        Low
3        Low
4        Low
        ... 
53935    Mid
53936    Mid
53937    Mid
53938    Low
53939    Mid
Name: new_cut, Length: 53940, dtype: category
Categories (3, object): ['Low' < 'Mid' < 'High']

对第4问中按照分位数分箱得到的序列，求每个样本对应所在区间的左右端点值和长度。

my_interval = pd.IntervalIndex(pd.qcut(avg_price, q=q))
my_interval

IntervalIndex([(1051.162, 2295.0], (1051.162, 2295.0], (1051.162, 2295.0], (1051.162, 2295.0], (1051.162, 2295.0] ... (3073.293, 4031.683], (3073.293, 4031.683], (3073.293, 4031.683], (3073.293, 4031.683], (3073.293, 4031.683]],
              closed='right',
              dtype='interval[float64]')

print('每个样本对应所在区间的左右端点值和长度:')
my_interval.left

每个样本对应所在区间的左右端点值和长度:





Float64Index([1051.162, 1051.162, 1051.162, 1051.162, 1051.162, 1051.162,
              1051.162, 1051.162, 1051.162, 1051.162,
              ...
              3073.293, 3073.293, 3073.293, 3073.293, 3073.293, 3073.293,
              3073.293, 3073.293, 3073.293, 3073.293],
             dtype='float64', length=53940)

my_interval.right

Float64Index([  2295.0,   2295.0,   2295.0,   2295.0,   2295.0,   2295.0,
                2295.0,   2295.0,   2295.0,   2295.0,
              ...
              4031.683, 4031.683, 4031.683, 4031.683, 4031.683, 4031.683,
              4031.683, 4031.683, 4031.683, 4031.683],
             dtype='float64', length=53940)

my_interval.length

Float64Index([         1243.838,          1243.838,          1243.838,
                       1243.838,          1243.838,          1243.838,
                       1243.838,          1243.838,          1243.838,
                       1243.838,
              ...
              958.3899999999999, 958.3899999999999, 958.3899999999999,
              958.3899999999999, 958.3899999999999, 958.3899999999999,
              958.3899999999999, 958.3899999999999, 958.3899999999999,
              958.3899999999999],
             dtype='float64', length=53940)

码农公寓