pandas.Categorical  2019/1/7

 函数：

class pd.Categorical(values,categories =None,ordered=None,dtype=None,fastpath=False ) 经典R/S-plus分类变量

     分类只能采用有限固定数量的可能值(类别)。可有顺序，但数值运算（加法，除法，......）是不可能

     分类的所有值都在类别或np.nan中。之外值引发ValueError。顺序由类别的顺序定义，而不是值的词汇顺序

     可以储存在Series or DataFrame. 字符串若能用分类表示则能提升性能

参数：

属性

categories

codes

ordered

dtype

方法：

from_codes

__array__

实例1：创建category分类类型

[code]# 实例1：非排序
cat = pd.Categorical([1, 2, 3, 1, 2, 3])
# [1, 2, 3, 1, 2, 3]
# Categories (3, int64): [1, 2, 3]

# 实例2.1：排序
cat1 = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'], ordered=True)
# [a, b, c, a, b, c]
# Categories (3, object): [a < b < c]

# 实例2.2：自定义顺序进行排序
cat2 = pd.Categorical(['a','b','c','a','b','c'],ordered=True, categories=['c','b','a'])
# [a, b, c, a, b, c]
# Categories (3, object): [c < b < a]

cat2.min() # 'c'

# 实例3：
cat3=pd.Categorical.from_codes(cat1.codes,cat1.categories)
# [a, b, c, a, b, c]
# Categories (3, object): [a, b, c]

cat3.as_ordered().min()#类别对象必须有序 # 'a'

实例2：属性

[code]cat.categories # 分类名称# Int64Index([1, 2, 3], dtype='int64')
cat1.categories# 分类名称# Index(['a', 'b', 'c'], dtype='object')

cat.codes # 此类别的类别代码# array([0, 1, 2, 0, 1, 2], dtype=int8)
cat1.codes# 此类别的类别代码# array([0, 1, 2, 0, 1, 2], dtype=int8)

cat.ordered # 类别无序# False
cat1.ordered# 类别有序# True

cat.dtype  # CategoricalDtype(categories=[1, 2, 3], ordered=False)
cat1.dtype # CategoricalDtype(categories=['a', 'b', 'c'], ordered=True)

实例3：category转np数组 

[code]pd.Categorical.__array__(cat1)# array(['a', 'b', 'c', 'a', 'b', 'c'], dtype=object)
np.asarray(cat1)              # array(['a', 'b', 'c', 'a', 'b', 'c'], dtype=object)

实例4：数据为元祖列表 

[code]# 假设有一组人员数据，划分为不同的年龄组：

ages = (20, 22, 25, 27, 21, 23 , 37, 31, 61, 45, 41, 32)
bins = (10, 30, 50, 70)#数据拆分为面元
cats = pd. cut(ages, bins)

# [(10, 30], (10, 30], (10, 30], (10, 30], (10, 30], ..., (30, 50], (50, 70], (30, 50], (30, 50], (30, 50]] Length: 12
# Categories (3, interval[int64]): [(10, 30] < (30, 50] < (50, 70]]

cats.categories
# IntervalIndex([(10, 30],(30,50],(50,70]]closed='right',dtype='interval[int64]')

cats.codes
# array([0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1], dtype=int8)

pd.value_counts(cats)

(10, 30] 6
(30, 50] 5
(50, 70] 1
dtype: int64

实例5：df 

[code]df = pd.DataFrame({"id":[11,12,13,14], "grade":['a', 'b', 'b','c']})
result1=df.dtypes

df['grade1']=df['grade'].astype('category')
df['grade1']=pd.Series(df['grade'],dtype='category') #等效

result2=df.dtypes

df['grade1']=df['grade1'].cat.set_categories(['big','mid','low'],rename=True)
result3=df.groupby("grade1").size()

# result1                result1                    df
result3
id       int64          id grade grade1       grade1
id      int64        grade    object      0  11     a    big          big    1
grade   object       grade1   category    1  12     b    mid          mid    2
dtype:  object       dtype: object        2  13     b    mid          low    1
3  14     c    low          dtype: int64

Series.cat分类对象 2019/1/7

1.函数： 

[code]s.cat.rename_categories(*args, **kwargs)  # 重命名类别 categories.
s.cat.reorder_categories(*args, **kwargs) # 重排new_categories中指定类别
s.cat.add_categories(*args, **kwargs)     # 添加新类别
s.cat.remove_categories(*args, **kwargs)  # 删除指定的类别
s.cat.remove_unused_categories(*args, **kwargs)# 删除未使用的类别。
s.cat.set_categories(*args, **kwargs)# 将类别设置为指定的new_categories
s.cat.as_ordered(*args, **kwargs)    # 设置分类为有序
s.cat.as_unordered(*args, **kwargs)  # 将Categorical设置为无序

实例2.1：s.cat.rename_categories

[code]s.cat.rename_categories(*args, **kwargs)#重命名类别 categories.

参数
new_categories：列表(值唯一,数量匹配)，dict(旧:新)或可函数
inplace=False：False返回副本 True原地重命名

# 实例1：list
s = Categorical(['a', 'a', 'b'])
s.rename_categories([0, 1]) # [0, 0, 1] Categories (2, int64): [0, 1]

# 实例2：dict
s.rename_categories({'a': 'A', 'c': 'C'}) #[A, A, b] Categories (2, object): [A, b]

# 实例3：函数
s.
24000
rename_categories(lambda x: x.upper())# [A, A, B] Categories (2, object): [A, B]

实例2.2：s.cat.reorder_categories

[code]s.cat.reorder_categories(*args, **kwargs)#重排new_categories中指定类别
参数
new_categories：类别名列表，顺序就是排序的顺序
inplace=False：False返回副本 True原地重命名
ordered：布尔值，可选# 分类是否被视为有序分类。

实例：
s=pd.Series(['v1','v3','v2','v1'],dtype='category')
s.cat.categories# Index(['v1', 'v2', 'v3'], dtype='object')

s.cat.categories=list('acb')
s.cat.categories# Index(['a', 'c', 'b'], dtype='object')

s=s.cat.reorder_categories(list('abc'))                          #重排new_categories中指定类别
s.cat.reorder_categories(new_categories=list('abc'),inplace=True)#等价就地修改
s.cat.categories# Index(['a', 'c', 'b'], dtype='object')

实例2.3：s.cat.add_categories

[code]s.cat.add_categories(*args, **kwargs)# 添加新类别
参数
new_categories：类别或类别列表#要包含的新类别,将包含在最后/最高位置
inplace=False：原地添加类别或返回副本

实例：
s=s.cat.add_categories(['d','e'])           #副本
s.cat.add_categories(['d','e'],inplace=True)#等价就地修改
s.cat.categories #Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

实例2.4：s.cat.remove_categories

[code]s.cat.remove_categories(*args, **kwargs)# 删除指定的类别
参数：
removals：类别或类别列表 #应删除的类别，必须存在
inplace=False：原地添加类别或返回副本

实例：
s.cat.remove_categories(['d'],inplace=True)#类别d在Series中未用
s.cat.categories #Index(['a', 'b', 'c', 'e'], dtype='object')

s.cat.remove_categories(['c'],inplace=True)#类别c在Series中使用，删除后用nan值替代
s

0 a
1 b
2 NaN
3 a
dtype: category
Categories (3, object): [a, b, e]

实例2.5：s.cat.remove_unused_categories

[code]s.cat.remove_unused_categories(*args, **kwargs)# 删除未使用的类别。
参数:
inplace=False：原地添加类别或返回副本

实例:
s.cat.remove_unused_categories(inplace=True)#就地修改
s.cat.categories                            # Index(['a', 'b'], dtype='object')

实例2.6：s.cat.set_categories 

[code]s.cat.set_categories(*args, **kwargs)# 将类别设置为指定的new_categories
参数：
new_categories：类别或类别list,包含新旧类别名
# 项目少于或多于旧类别将导致值设置为NaN或未使用的类别
ordered=False # 分类是否被视为有序分类
rename=False  # True将new_categories视为重命名
inplace=False # 原地添加类别或返回副本

实例：
s.cat.set_categories(list('abcd'),inplace=True)          #添加类别c,d
s.cat.categories #Index(['a', 'b', 'c', 'd'], dtype='object')

s.cat.set_categories(list('AB'),inplace=True,rename=True)#重命名类别,并删除c,d
s.cat.categories                                         #Index(['A', 'B'], dtype='object')

实例2.7：s.cat.as_ordered 

[code]s.cat.as_ordered(*args, **kwargs)# 设置分类为有序
参数
inplace=False # 原地添加类别或返回副本

实例：
s.cat.ordered #False

s.cat.as_ordered(inplace=True)
s.cat.ordered #True

实例2.8：s.cat.as_unordered

[code]s.cat.as_unordered(*args, **kwargs)#将Categorical设置为无序
参数
inplace=False # 原地添加类别或返回副本

实例：
s.cat.ordered#True

s.cat.as_unordered(inplace=True)
s.cat.ordered# False