1. Name Brand Cloth Count
2. girl uniql sweater 3
3. girl etam suit 1
4. girl etam pants 1
5. girl lagogo jacket 2
6. boy pants 2
7. boy hailan t-shirt 1
8. mother hengyuanxiang coat 2
9. mother hengyuanxiang sweater 1
10. mother coat 1
11. father hailan t-shirt 2
12. father hailan sweater 1
13. father hailan pants 3本文数据源如上，Name:在家庭中的身份， Brand:衣服品牌， ClothType：衣服数量，Count:衣服数量
import pandas as pd
data=pd.read_excel('testdata.xlsx')如果是csv文件：import pandas as pd
data=pd.read_csv('testdata.csv',sep=',')查看data的内容：
1. data
2. Out[1]:
3. Name Brand Cloth Count
4. 0 girl uniql sweater 3
5. 1 girl etam suit 1
6. 2 girl etam pants 1
7. 3 girl lagogo jacket 2
8. 4 boy NaN pants 2
9. 5 boy hailan t-shirt 1
10. 6 mother hengyuanxiang coat 2
11. 7 mother hengyuanxiang sweater 1
12. 8 mother NaN coat 1
13. 9 father hailan t-shirt 2
14. 10 father hailan sweater 1
15. 11 father hailan pants 3获取列名：
1. data.columns
2. Out[2]: Index(['Name', 'Brand', 'Cloth', 'Count'], dtype='object')
3. data.columns[0]
4. Out[2]: 'Name'
5. data.columns[1]
6. Out[3]: 'Brand'获取index:
1. data.index
2. Out[3]: RangeIndex(start=0, stop=12, step=1)从0开始，到12停，不包括12.所以一共有12行数据
获取values:
1. data.values
2. Out[4]:
3. array([['girl', 'uniql', 'sweater', 3],
4. 'girl', 'etam', 'suit', 1],
5. 'girl', 'etam', 'pants', 1],
6. 'girl', 'lagogo', 'jacket', 2],
7. 'boy', nan, 'pants', 2],
8. 'boy', 'hailan', 't-shirt', 1],
9. 'mother', 'hengyuanxiang', 'coat', 2],
10. 'mother', 'hengyuanxiang', 'sweater', 1],
11. 'mother', nan, 'coat', 1],
12. 'father', 'hailan', 't-shirt', 2],
13. 'father', 'hailan', 'sweater', 1],
14. 'father', 'hailan', 'pants', 3]], dtype=object)获取某一行：
1. data.values[1]
2. Out[5]: array(['girl', 'etam', 'suit', 1], dtype=object)获取某一格：
1. data.values[1][2]
2. Out[6]: 'suit'按某一列关键字分组：
1. gp=data.groupby('Brand')#写data.groupby(data['Brand'])也是一样的
2. gp
3. Out[10]: <pandas.core.groupby.DataFrameGroupBy object at 0x0000000008309B38>
4. type(gp)
5. Out[11]: pandas.core.groupby.DataFrameGroupBygp是一个把dataframe groupby以后的对象，它实际上还没有进行任何计算，只是一个暂时存储的容器。
对这个暂时存储的容器进行计数，因为是按'Brand'分的组，：
1. gp.count()
2. Out[13]:
3. Name Cloth Count
4. Brand
5. etam 2 2 2
6. hailan 4 4 4
7. hengyuanxiang 2 2 2
8. lagogo 1 1 1
9. uniql 1 1 1看到按'Brand'分组后的这个结果，Name,Cloth,Count列在每种Brand所对应行的数字都一样，比如：2 2 2.可以理解为每种Brand各有多少行数据,把这个行数显示在所有列。
因为我们选择时是data.groupby(),而不是data['Count'].groupby()
p.s.:可以看到分组计数后的index是'Brand‘，这是因为分组是按'Brand’字段分的
1. gp.count().index
2. Out[14]: Index(['etam', 'hailan', 'hengyuanxiang', 'lagogo', 'uniql'], dtype='object', name='Brand')
想知道每种Brand的衣服有多少人穿多少种，其实只看 Count列就行了。
比如father虽然有2件T-shirt,1件sweater,3件pants，还是算1个人穿3种hailan。boy有一件hailan的t-shirt,算1个人穿1种hailan。所以hailan对应4。 总之，count()函数可以理解为对Count列去重的和。
1. gp1=data['Count'].groupby(data['Brand'])
2. gp1.count() #和gp1.size()结果一样
3. Out[20]:
4. Brand
5. etam 2
6. hailan 4
7. hengyuanxiang 2
8. lagogo 1
9. uniql 1
10. Name: Count, dtype: int64
想求某品牌被人均拥有的件数的平均值：
比如hailan就是father的2件T恤，1件毛衣，3条裤子，还有boy的1件T恤。 （2+1+3+1)/4=1.75。 分母4可以理解为刚才所说的 gp1.count() :每种Brand的衣服有多少人穿多少种
比如hengyuanxiang就是mother的2件大衣，1件毛衣 ,（2+1）/2=1.5
1. gp1.mean()
2. Out[21]:
3. Brand
4. etam 1.00
5. hailan 1.75
6. hengyuanxiang 1.50
7. lagogo 2.00
8. uniql 3.00
9. Name: Count, dtype: float64 说明：type(gp1.mean()) 是 Series类型。之所以index叫'Brand',是因为原datafram是按'Brand' groupby的
想求某品牌被每人拥有的件数：（与“”想知道每种Brand的衣服有多少人穿多少种“ .count( ）算法的区别在于 不去重）
在Count列上加和
1. gp1.agg(sum) #就是 data['Count'].groupby(data['Brand']).agg(sum) , agg里也可以写'sum'，与不加单引号等效
2. Out[5]:
3. Brand
4. etam 2
5. hailan 7
6. hengyuanxiang 3
7. lagogo 2
8. uniql 3
9. Name: Count, dtype: int64
综上所述可以观察出，gp1.mean()操作的结果等于 gp1.agg(sum)/gp1.count()
遍历分组：
1. for name,group in data.groupby(data['Brand']):
2. print(name)
3. print(group)
4.
5. etam
6. Name Brand Cloth Count
7. 1 girl etam suit 1
8. 2 girl etam pants 1
9. hailan
10. Name Brand Cloth Count
11. 5 boy hailan t-shirt 1
12. 9 father hailan t-shirt 2
13. 10 father hailan sweater 1
14. 11 father hailan pants 3
15. hengyuanxiang
16. Name Brand Cloth Count
17. 6 mother hengyuanxiang coat 2
18. 7 mother hengyuanxiang sweater 1
19. lagogo
20. Name Brand Cloth Count
21. 3 girl lagogo jacket 2
22. uniql
23. Name Brand Cloth Count
24. 0 girl uniql sweater 3由上可以看出，brand为NaN 的衣服并没有被分组，自动忽略不计了。
对于由DataFrame产生的GroupBy对象，如果用一个（单个字符串）或一组（字符串数组）列名对其进行索引，就能实现选取部分列进行聚合的目的，即：
写法一：
1. data.groupby('Brand')['Count'].sum()#等价于data.groupby('Brand')['Count'].agg(sum)，等价于data.groupby('Brand')['Count'].agg('sum')#等价于data.groupby('Brand').agg('sum')['Count'],等价于data.groupby('Brand').agg(sum)['Count'],等价于data.groupby('Brand').sum()['Count']
2. Out[13]:
3. Brand
4. etam 2
5. hailan 7
6. hengyuanxiang 3
7. lagogo 2
8. uniql 3
9. Name: Count, dtype: int64这和写法二：
1. data['Count'].groupby(data['Brand']).sum()
2. Out[19]:
3. Brand
4. etam 2
5. hailan 7
6. hengyuanxiang 3
7. lagogo 2
8. uniql 3
9. Name: Count, dtype: int64是等效的
注意写法一里面的'Brand'不用必须写成（当然也可以写成）data['Brand']，是因为data.groupby()由于是对data这个dataframe调用的方法，所以能识别出data的字段'Brand'。但是写法二是对data['Count'] 这个Series对象调用的groupby,不认识'Brand'，只认识data['Brand'],如果写法二还写成.groupby('Brand')就会报错。
双索引分组：
想知道每人拥有每种品牌的衣服多少种类型（类型就是Cloth字段，写成ClothType大家更容易理解哈）：
1. data.groupby(['Name','Brand'])['Count'].count() #和写.size( )效果一样
2. Out[31]:
3. Name Brand
4. boy hailan 1
5. father hailan 3
6. girl etam 2
7. 1
8. 1
9. mother hengyuanxiang 2
10. Name: Count, dtype: int64从结果可以看出，对boy拥有的没Brand的一条裤子，和mother没牌子的一件大衣，都自动忽略不计了。
