前言

大数据时代，数据的重要性不言而喻，掌握数据者得天下。很多同学可能对一堆数据不知如何进行处理分析得到有用的信息，本文主要基于anaconda 简单介绍 Numpy 模块的使用，重点演示 Pandas 的应用。

• 数据分析：把隐藏在一些看似杂乱无章的数据背后的信息提炼出来，总结出所研究对象的内在规律
• 数据分析三剑客：Numpy，Pandas，Matplotlib
• Numpy与Padas是数据结构、Matplotlib绘图使用

0. 环境准备

# 环境变量 for zsh，并为 anaconda 的pip命别名
export PATH=$PATH:/Applications/anaconda3/bin
alias cpip="/Applications/anaconda3/bin/pip"
source ~/.zhsrc

1. numpy

• NumPy(Numerical Python)：Python语言的一个扩展程序库，支持大量的维度数据与矩阵运算，针对数组提供大量的数学函数库。

1. 使用np.array()创建

• 数组

import numpy as np
# 一维数组
np.array([1,2,3])
# 二维数组
np.array([[1,2,3], [4,5,6]])
# 返回值优先级：str > float > int

• matplotlib绘图

import matplotlib.pylab as plt
# 返回一个数组，图片是三维数据
img_arr = plt.imread(‘./cat.jpg‘)
plt.imshow(img_arr)
plt.imshow(img_arr-100)

2. np的数组(4)

• linspace

# 平均生成 num 个 start-stop数据
np.linspace(start, stop, num)

• arange：等差数列

# start 默认是 0， step默认是 1, 给定 step 必须有start
np.arange([start,] stop[, step,], dtype=None)
# 不包含 10
np.arange(0, 10, 2)

• random.randint()：随机数

# [low, high)，high=None表示 [0-low), size=(1,2,3...)表示维度
np.random.randint(randint(low, high=None, size=None, dtype=‘l‘)
# 固定随机性，随机因子(系统时间)
np.random.seed(10)
np.random.randint(0,100, size=(4,5))

• random.random(size)

# 默认大小是 0-1
np.random.random(size=(4,5))

3. ndarray属性(3)

arr.shape                   # (4,5)，返回的是数组的形状
arr.size                    # 元素个数
arr.dtype                   # (‘int64‘)，数据类型

4. 操作(4)

• 索引

arr[1]                      # 第一个元素，索引从 0 开始
arr[2, 3]                   # 第二行第三列元素

• 切片

arr[0:2]                    # 前两行
arr[:, 0:2]                 # , 左边是行，右边是列
arr[::-1]                   # 行倒序
arr[:, ::-1]                # 列倒序
arr[:, ::-1, :]

• 变形：参数是一个tuple

arr.reshape()
# 容量必须刚刚好
arr.reshape((20,))
arr.reshape((1, 20))
arr.reshape(1, 20)
# 自动计算行数
arr.reshape((-1, 4))

• 级联
  • 数据的拼接，注意行或列的长度

# axis=0 表示作用于行(纵向拼接)，axis=1作用于列(横向拼接)
np.concatenate((arr, arr), axis=0)

• 算术运算
  • 广播机制：如果两个数组的后缘维度(从末尾开始算起的维度)的轴长度相符或其中一方的长度为1，则认为它们是广播兼容的。广播会在缺失维度和(或)轴长度为1的维度上进行。

b = np.array([[1],[2],[3]])
a = np.array([1,2,3])
b-a
--> array([[ 0, -1, -2],
       [ 1,  0, -1],
       [ 2,  1,  0]])

5. ndarray聚合

• np.sum/mean

arr.sum(axis=None)              # 计算所有元素的和
arr.sum(axis=0)                 # 作用于列，数据并到一行。列的和
arr.sum(axis=1)                 # 作用于行，数据并到一列。行的和
arr.mean(axis=None/0/1)         # 平均数

• 其他

np.sqrt(arr)                    # 开方
np.prod(arr)                    # 所有元素相乘
np.min(arr)                     # 最小值
np.max(arr)                     # 最大值
np.std(arr)                     # 标准差
np.var(arr)                     # 方差
np.median(arr)                  # 中数
np.power(arr,2)                 # 幂运算
np.argmin(arr)                  # 最小值的下标
np.argmax(arr)                  # 最大值的下标
np.inf                          # 无穷大
np.exp(10)                      # 以e为底的指数，e**10
np.log(10)                      # 对数，e为底

6. ndarray排序

• sort排序

# axis默认-1：表示按照上次的排序规则排序
# axis=0：表示按照列元素排序，1表示行元素排序
np.sort(arr, axis=-1, kind=‘quicksort‘, order=None)

# 列元素排序，列有序，arr被修改
arr.sort(axis=0)
# 列元素排序，列有序，不改变原数据
np.sort(arr, axis=0)

Note(2)

1. axis=0：表示针对行进行计算或排序，列有序
2. axis=1：表示针对列进行计算或排序，行有序

2. pandas

? SQL中的select是根据列的名称来选取；Pandas则更为灵活，不但可根据列名称选取，还可以根据列所在的position（数字，在第几行第几列，注意pandas行列的position是从0开始）选取。相关函数如下：

loc                     # 基于列label，可选取特定行（根据行index)
iloc                    # 基于行/列的position(默认的索引，整型)
at                      # 根据指定行index及列label，快速定位DataFrame的元素
iat                     # 与at类似，不同的是根据position来定位的
ix                      # 为loc与iloc的混合体，既支持label也支持position

• 导入需要的包

import pandas as pd
from pandas import Series, DataFrame
import numpy as np

1. Series

1. 创建和去重

• 是一种类似与一维数组的对象
  • values：一组数据（ndarray类型）
  • index：相关的数据索引标签
• 创建：由列表或numpy数组创建
  • 默认索引为0到N-1的整数型索引
  • 一定是一维的数据结构
  • 隐式索引和显示索引可以共存

Series(data=[1,2,3])                    # 隐式索引
Series(data=[1,2,3], index=[a,b,c])     # 显示索引，提高可读性
Series(data=np.random.randint(0,100, size=(4)))

s = Series(data=[1,1,1,2,3,4,5,5,6])
# 去重
s.unique()
# NaN表示空，浮点类型
运算：只能针对索引对齐的数据运算，否则为NaN
# 空值检测
pd.isnull(arr) 或 s.isnull()
pd.notnull(arr) 或 s.notnull()
s[[True, True, False, False]]
s[s.notnull()]                          # 空值过滤

2. Series的索引

• 可以使用中括号取单个索引（此时返回的是元素类型），或者中括号里一个列表取多个索引（此时返回的是一个Series类型）。
• 显式索引
  • 使用index中的元素作为索引值
  • 使用s.loc[]（推荐）:注意，loc中括号中放置的一定是显示索引
  • 注意，此时是闭区间

s = Series([1,2,3,4], index=[‘a‘, ‘b‘, ‘c‘, ‘d‘])

• 隐式索引
  • 使用整数作为索引值
  • 使用s.iloc[]（推荐）s:iloc中的中括号中必须放置隐式索引
  • 注意，此时是半开区间

s = Series([1,2,3,4])

3. 切片：隐式索引和显示索引切片

• 显示索引切片：index和loc

s[‘a‘:‘b‘]                              # [‘a‘, ‘b‘]
s.loc[‘a‘:‘b‘]

• 隐式索引：iloc

s[0:3]                                  # [0, 3)
s.iloc[0:3]

4. Series基本概念

• 可以通过shape，size，index,values等得到series的属性

s.index                                 # 索引
s.values                                # 值
s.size                                  # 长度
s.shape                                 # (n,)

• 可以使用s.head(),tail()分别查看前n个和后n个值，head默认为 5

s.head(2)
s.tail(2)

• 去重

s.unique()

• Series的运算：索引一致则相加，不一致则为Na

# + - * /
# add() sub() mul() div() 

# s1 + s2， 索引相同则相加，不同则保留切 +fill_value(float类型)
s1.add(s2,fill_value=0)
s1.mul(s2,fill_value=1)

Note(2)

1. 默认格式：dtype: int64
2. Series之间的运算，自动对齐不同索引的数据，如果索引不对应，则补NaN

2. DataFrame

1. DataFrame简介

• DataFrame是一个【表格型】的数据结构。DataFrame由按一定顺序排列的多列数据组成。设计初衷是将Series的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。
  1. 行索引：index
  2. 列索引：columns
  3. 值：values

2. 创建DataFrame

• 最常用的方法是传递一个字典来创建。DataFrame以字典的键作为每一【列】的名称，以字典的值（一个数组）作为每一列。
  1. 此外，DataFrame会自动加上每一行的索引。
  2. 使用字典创建的DataFrame后，则columns参数将不可被使用。
  3. 同Series一样，若传入的列与字典的键不匹配，则相应的值为NaN。

# 使用ndarray创建DataFrame
df = DataFrame(data=np.random.randint(0,100, size=(3,3)), index=(‘a‘, ‘b‘, ‘c‘), columns=(‘1‘, ‘2‘, ‘3‘))

# 使用 dic 创建DataFrame
dic = {
    ‘张三‘:[11,22,33,44],
    ‘李四‘:[55,66,77,88]
}
df_score = DataFrame(data=dic,index=[‘语文‘,‘数学‘,‘英语‘,‘理综‘])

# 属性：shape、index、colums、values
df.shape / .index  /.colums /.vlues

3. DataFrame的索引

• 数据准备

df=DataFrame(np.random.randint(0,100, size=(3,3)), index=(‘a‘,‘b‘,‘c‘), columns=(‘A‘,‘B‘,‘C‘))

• 对列进行索引(2)
  • 通过类似字典的方式 df[‘q‘]
  • 通过属性的方式 df.q
  • 可以将DataFrame的列获取为一个Series。返回的Series拥有原DataFrame相同的索引，且name属性也已经设置好了，就是相应的列名。

df.A / df[‘A‘]                  # 取一列，即一个 Series对象
df[[‘A‘, ‘B‘]]                  # 取 A、B两列

• 对行进行索引(2)
  • 使用.loc[]加index来进行行索引
  • 使用.iloc[]加整数来进行行索引
  • 同样返回一个Series，index为原来的columns。

df.loc[[‘a‘,‘b‘]]               # 取 a、b 两行
df.iloc[[0, 1]]                 # 取 a、b 两行

• 对元素索引

df.loc[‘a‘, ‘3‘]                # 取一个值，类似坐标取值
df.loc[[‘a‘, ‘c‘], ‘3‘]         # 取多个值
df.loc[[‘a‘,‘c‘], [‘1‘, ‘2‘]]

4. 切片

• 【注意】 直接用中括号时
  • 索引表示的是列索引
  • 切片表示的是行切片

# 切出前两行
df[‘a‘:‘b‘]
df[0:2]
# 切出前两列
df.loc[:, ‘A‘:‘B‘]
df.iloc[:, 0:2]
# 按照行列切片
df.loc[‘a‘:‘b‘, ‘1‘:‘2‘]

5. 运算

• 和Series一样
  • 在运算中自动对齐不同索引的数据
  • 如果索引不对应，则补NaN

6. 删除

df.drop(1)                      # 默认删除行，即 axis=0

3. 股票示例

• df.to_save(‘xxx.csv‘)
• pd.read_csv(‘xxx.csv‘, index_col=‘date‘, parse_dates=True)：把字符串日期转为 Timestamp
• df.drop(labels=[‘列名‘], axis=1 ,inplace=True)：删除某一列
• df[‘close‘].shift(1)：向下移动一个单元，对齐其他列的下一行
• new_df.resample(‘M‘).first()：获取每个月的第一条
• new_df.resample(‘A‘).last()：获取每年的最后一条

# tushare 股票数据获取模块
import tushare as ts
import pands as pd

# 获取 股票代码 600519 从2001.1.1的交易数据
df = ts.get_k_data(code=‘600519‘,start=‘2000-01-01‘)
# 把数据保存到本地 maotai.csv 中
df.to_csv(‘./maotai.csv‘)
# 使用 pandas 读取文件
df = pd.read_csv(‘./maotai.csv‘)
# 删除某一列
df.drop(labels=[‘Unnamed: 0‘], axis=1, inplace=True)
# 把字符串的日期转换为 Timestamp 类型
df = pd.read_csv(‘./maotai.csv‘,index_col=‘date‘,parse_dates=[‘date‘])
# 查看转换结果
df.index[0]
df.columns[0]

• 输出该股票所有收盘比开盘上涨3%以上的日期。

# (收盘-开盘)/开盘 > 0.03
df[(df.open - df.close)/df.open > 0.03]
#将行索引取出
df.loc[(df[‘close‘] - df[‘open‘]) / df[‘open‘] > 0.03].index

• 输出该股票所有开盘比前日收盘跌幅超过2%的日期。

# (开盘-前日收盘)/前日收盘  < -0.02
df[(df.open - df.close.shift(1)) / df.close.shift(1) < -0.02].index

• 假如我从2010年1月1日开始，每月第一个交易日买入1手股票，每年最后一个交易日卖出所有股票，到今天为止，我的收益如何？

# 2010-2019, M：表示按月份取，A：表示按年取
new_df = df[‘2010-01-01‘:‘2019-09-03‘]
df_monthly = new_df.resample(‘M‘).first()
# 除了最后一条数据
df_yearly = new_df.resample(‘A‘).last()[:-1]

# 计算买入股票花费
cost = df_monthly[‘open‘].sum() * 100
recv = df_yearly[‘open‘].sum() * 1200
recv = 900 * new_df[-1:][‘open‘] + recv
recv - cost

pandas的数据处理

1. 处理丢失的数据

numpy：没有异常值清洗

1. None和np.nan(NaN)

• None：是python的object，nonetype，不能参与任何计算
• np.nan：是浮点类型，能参与计算中，计算结果还是NaN，不会影响整体的运算
• pandas中的None和NaN都强转为 np.nan

2. 数据清洗

• 如果出现NaN，可以把携带NaN的行删除或者替换NaN

1. pandas处理空值(3)

• isnull()
• notnull()
• dropna()：过滤丢失的数据
• fillna()：填充丢失的数据

# 空值检测
df.isnull()
df.notnull()
# True 和 False 的判定 
df.notnull().any(axis=1)    # any表示or
df.notnull().all(axis=1)    # and
# 去掉包含 NaN 的行，notnull + all， isnull + any
# 将 df.notnull().all(axis=1)作为原数据的索引，就可以将对应的空进行删除
df.loc[df.notnull().all(axis=1)] or
indexs = df.loc[df.isnull().any(axis=1)].index
df.drop[labels=indexs, axis=0]
# 将 df.isnull().any(axis=1)作为原数据的索引，就可以将对应的空进行保留
df.loc[df.isnull().any(axis=1)]

• df.dropna(axis=0)：删除空行
• df.fillna(axis=0)：用列的值进行替换

# 直接删除空行
df.dropna(axis=0)
# 替换，ffill/bfill：forward/backward fill。用上(下)一行进行覆盖空值行数据
df.fillna(value=‘目标值‘, method=‘ffill‘, axis=0)

• 读取excel

df = pd.read_excel(‘文件路径.xlsx‘, sheet_name=‘xxx‘)
df = df.drop(labels=[‘none‘, ‘none1‘], axis=1 inplace=True)
# 清洗，删除空对应的行数据，方式一
df.dropna(axis=0)
# 方式二
df.loc[df.notnull().all(axis=1)]

# 清洗，替换空对应的行数据
df=df.fillna(method=‘ffill‘, axis=0).fillna(method=‘bfill‘, axis=0)
# 检测 df 列中是否还有空值
df.notnull().all(axis=0)
df.isnull().any(axis=0)

2. pandas级联

1. pd.concat()级联

1. axis=0/1
2. join=‘outer‘/‘inner‘
3. 不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致。有2种连接方式：
   • 外连接：补NaN（默认模式）
   • 内连接：只连接匹配的项

df1 = DataFrame(np.random.randint(1,100, size=(5,5)))
df2 = DataFrame(np.random.randint(1,100, size=(5,5)))
# 匹配级联
pd.concat((df1, df1), axis=0, join=‘outer‘)
# 不匹配级联，索引不同会有空值
pd.concat((df1, df2), axis=0, join=‘outer‘, sort=True)

2. pd.merge()合并

• 一次只能用于两张表，用于数据的整合
• 参数说明
  1. left， right，
  2. how=‘inner/outer/left/right‘
  3. on=‘列名‘ , left_on=‘‘, right_on=‘‘
• merge与concat的区别在于，merge需要依据某一共同的列来进行合并，使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并。
• 注意每一列元素的顺序不要求一致
• 数据准备

# df1 数据一
dic1 = {
    ‘name‘:[‘henry‘,‘echo‘, ‘dean‘, ‘tom‘],
    ‘apartment‘:[‘tech‘,‘sale‘,‘hr‘, ‘xx‘],
}
df1 = DataFrame(dic1, index=[‘a‘, ‘b‘, ‘c‘])
# df2 数据二
dic2 = {
    ‘apartment‘:[‘tech‘,‘sale‘,‘hr‘, ‘acctounting‘],
    ‘supervisor‘:[‘diane‘, ‘oleg‘, ‘iris‘, ‘elaine‘]
}
df2 = DataFrame(dic2, index=[‘a‘, ‘b‘, ‘c‘])
df2

1. 一对一

# 默认合并条件是相同的数据
pd.merge(left=df1, right=df2, on=‘apartment‘)

2. 一对多

pd.merge(left=df1, right=df2, on=‘apartment‘, how=‘outer‘)

3. 多对多

pd.merge(left=df1, right=df2, on=‘apartment‘, how=‘inner‘)
pd.merge(left=df1, right=df2, on=‘apartment‘, how=‘outer‘)
pd.merge(left=df1, right=df2, on=‘apartment‘, how=‘left‘)
pd.merge(left=df1, right=df2, on=‘apartment‘, how=‘right‘)

3. key的规范化

• 如果有两列名一样，on条件默认采用共同的合并条件
• 合并条件的值不会重复出现，其他列名相同的值会重复出现(列名加后缀)
• 当列冲突时，即有多个列名称相同时，需要使用on=来指定哪一个列作为key，配合suffixes指定冲突列名

pd.merge(left=df1, right=df2, left_on=‘apartment‘,right_on=‘apart‘, how=‘right‘)

4. 人口分析案例

# 需求：
1. 导入文件，查看原始数据
2. 将人口数据和各州简称数据进行合并
3. 将合并的数据中重复的abbreviation列进行删除 
4. 查看存在缺失数据的列 
5. 找到有哪些state/region使得state的值为NaN，进行去重操作 
6. 为找到的这些state/region的state项补上正确的值，从而去除掉state这一列的所有NaN 
7. 合并各州面积数据areas 
8. 我们会发现area(sq.mi)这一列有缺失数据，找出是哪些行,去除含有缺失数据的行 
9. 找出2010年的全民人口数据 
10.计算各州的人口密度 排序，并找出人口密度最高的五个州 df.sort_values()

• how=‘outer‘：要保留所有数据
  • 数据分析中要保证数据的完整性

import pandas as pd
import numpy as np
from pandas import Series, DataFrame

peo = pd.read_csv(‘./data/state-population.csv‘)
area = pd.read_csv(‘./data/state-areas.csv‘)
abbr = pd.read_csv(‘./data/state-abbrevs.csv‘)

# 将人口数据和各州简称数据进行合并
# 将合并的数据中重复的abbreviation列进行删除
abbr_peo = pd.merge(abbr, peo, left_on=‘abbreviation‘, right_on=‘state/region‘, how=‘outer‘)
abbr_peo.drop(labels=‘abbreviation‘, axis=1,inplace=True)
abbr_peo.head(2)

# 查看存在缺失数据的列
abbr_peo.isnull().any(axis=0)
# 找到有哪些state/region使得state的值为NaN，进行去重操作
abbr_peo.loc[abbr_peo.state[abbr_peo.state.isnull()].index][‘state/region‘].unique()
# 为找到的这些state/region的state项补上正确的值，从而去除掉state这一列的所有NaN 
indexs = abbr_peo[abbr_peo[‘state/region‘] == ‘PR‘].index
abbr_peo.loc[indexs, ‘state‘] = ‘PUERTO RICO‘
indexs = abbr_peo[abbr_peo[‘state/region‘] == ‘USA‘].index
abbr_peo.loc[indexs, ‘state‘] = ‘UNITED STATES‘

# 合并各州面积数据areas 
abbr_peo_area = pd.merge(abbr_peo, area, how=‘outer‘)
abbr_peo_area.head(2)
# 我们会发现area(sq.mi)这一列有缺失数据，找出是哪些行,去除含有缺失数据的行 
indexs = abbr_peo_area[abbr_peo_area[‘area (sq. mi)‘].isnull()].index
abbr_peo_area.drop(labels=indexs, axis=0, inplace=True)

# 找出2010年的全民人口数据
abbr_peo_area.query("ages==‘total‘and year==2010")
# 计算各州的人口密度 排序，并找出人口密度最高的五个州 df.sort_values()
abbr_peo_area.peo_dense = abbr_peo_area.population / abbr_peo_area[‘area (sq. mi)‘]
abbr_peo_area.head(2)
# 排序，并找出人口密度最高的五个州 df.sort_values()
abbr_peo_area.sort_values(by=‘peo_dense‘,axis=0, ascending=False).head(2)

3. pandas数据处理

1. drop_duplicates：删重

• df.drop_duplicates(keep=‘first/last‘/False)
• keep参数：指定保留哪一重复的行数据

df[0:2] = 6
df.iloc[5] = 6
# keep表示保留重复行的方式
df.drop_duplicates(keep=‘first/last‘/False)

2. map()：映射

1. replace(to_replace=[]/{}, value=‘xxx‘)：替换

• 使用replace()函数，对values进行映射操作
• 单值替换
  • 普通替换： 替换所有符合要求的元素:to_replace=15,value=‘e‘
  • 按列指定单值替换： to_replace={列标签：替换值} value=‘value‘
• 多值替换
  • 列表替换: to_replace=[] value=[]
  • 字典替换（推荐） to_replace={to_replace:value,to_replace:value}

# 指定单值替换，原数据为：64.0
df.replace(to_replace={64:‘xxx‘})
# 指定第三列的6替换
df.replace(to_replace={2:6}, value=‘six‘)

2. map()：映射

• 映射关系表：dict={}
• map()函数：新建一列，map函数并不是df的方法，而是series的方法
  1. map()可以映射新一列数据
  2. map()中可以使用lambd表达式
  3. map()中可以使用方法，可以是自定义的方法

注意 ：map()中不能使用sum之类的函数，for循环

dic = {
    ‘name‘:[‘周杰伦‘,‘张三‘,‘周杰伦‘],
    ‘salary‘:[15000,20000,15000]
}
df = DataFrame(data=dic)
df
    name    salary
0   周杰伦 15000
1   张三  20000
2   周杰伦 15000

# 映射关系表（字典）
dic = {
    ‘周杰伦‘:‘jay‘,
    ‘张三‘:‘tom‘
}
df[‘ename‘] = df.name.map(dic)

    name    salary  ename
0   周杰伦 15000   jay
1   张三  20000   tom
2   周杰伦 15000   jay

# map()，用法一
df.ename = df.name.map(dic)
# 用法二，在增加一列时，需要使用 [‘列名‘]，如果直接使用 .列名 会失败
df[‘neat_salary‘] = df.salary.map(lambda x: x - (x-3000)*0.5)
df

3. 使用聚合操作对异常值检测和过滤

• 使用df.std()函数可以求得DataFrame对象的标准差
• 创建一个1000行3列的df 范围（0-1），求其每一列的标准差

# 生成测试的随机数据
df = DataFrame(np.random.random(size=(1000, 3)), columns=[‘A‘, ‘B‘, ‘C‘])
# 计算C列的标准差，并获取不合格的索引
df.C.std()
indexs = df[df.C > 3*df.C.std()].index
indexs
# 删除
df.drop(labels=indexs, inplace=True, axis=0)

4. 排序

• 随机抽样：随机生成 0-n 的数组

np.random.permutation(5)

• take()：接收一个索引列表，用数字表示，使得df根据

df.take(indices=np.random.permutation(1000)).take(indices=np.random.permutation(3), axis=1).head()

5. 分组

1. 数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。
2. 数据分类处理
   • 分组：先把数据分为几组
   • 用函数处理：为不同组的数据应用不同的函数以转换数据
   • 合并：把不同组得到的结果合并起来
3. 数据分类处理的核心
   • groupby()函数
   • groups属性查看分组情况
   • eg: df.groupby(by=‘item‘).groups

• 数据准备

df = DataFrame({‘item‘:[‘Apple‘,‘Banana‘,‘Orange‘,‘Banana‘,‘Orange‘,‘Apple‘],
                ‘price‘:[4,3,3,2.5,4,2],
               ‘color‘:[‘red‘,‘yellow‘,‘yellow‘,‘green‘,‘green‘,‘green‘],
               ‘weight‘:[12,20,50,30,20,44]})
df

    item    price   color   weight
0   Apple   4.0 red 12
1   Banana  3.0 yellow  20
2   Orange  3.0 yellow  50
3   Banana  2.5 green   30
4   Orange  4.0 green   20
5   Apple   2.0 green   44

• groupby(‘分组条件‘)

df.groupby(by=‘item‘, axis=0)
df.groupby(by=‘item‘, axis=0).groups
# 执行结果
{‘Apple‘: Int64Index([0, 5], dtype=‘int64‘),
 ‘Banana‘: Int64Index([1, 3], dtype=‘int64‘),
 ‘Orange‘: Int64Index([2, 4], dtype=‘int64‘)}

• 聚合

mean_price = df.groupby(by=‘item‘, axis=0).price.mean()
df[‘mean_price‘] = df.item.map(mean_price)
df

color_price = df.groupby(by=‘color‘, axis=0).price.mean()
df[‘color_price‘] = df.color.map(color_price)
df

6. 高级聚合

• transform和apply都会进行运算，在transform或者apply中传入函数即可
• transform和apply也可以传入一个lambda表达式

def my_mean(p):
    sum = 0
    for i in p:
        sum += i
    return sum/len(p)

aplly_my_mean = df.groupby(by=‘item‘, axis=0).price.apply(my_mean)
df[‘apply_my_mean‘] = df.item.map(aplly_my_mean)
df

# 采用 transform 方法，transform是映射后的数据
transform_my_mean = df.groupby(by=‘item‘, axis=0).price.transform(my_mean)
df[‘transform_my_mean‘] = transform_my_mean
df

4. 美国12政治选举案例

• 需求

#字段说明
cand_nm(候选人姓名),contbr_nm（捐赠者姓名）, contbr_city,contbr_st, contbr_zip, contbr_employer, contbr_occupation（捐赠者的职业）, contb_receipt_amt（捐赠金额）, contb_receipt_dt（捐赠日期）
# 具体需求
1. 读取文件usa_election.txt
2. 查看文件样式及基本信息
3.【知识点】使用map函数+字典，新建一列各个候选人所在党派party
4. 使用np.unique()函数查看colums：party这一列中有哪些元素
5. 使用value_counts()函数，统计party列中各个元素出现次数，value_counts()是Series中的，无参，返回一个带有每个元素出现次数的Series
6.【知识点】使用groupby()函数，查看各个党派收到的政治献金总数contb_receipt_amt
7. 查看具体每天各个党派收到的政治献金总数contb_receipt_amt 。使用groupby([多个分组参数])
8. 将表中日期格式转换为‘yyyy-mm-dd‘。日期格式,通过函数加map方式进行转换
9. 得到每天各政党所收政治献金数目。  考察知识点：groupby（多个字段）
10.查看老兵(捐献者职业)DISABLED VETERAN主要支持谁  ：查看老兵们捐赠给谁的钱最多
11.找出各个候选人的捐赠者中，捐赠金额最大的人的职业以及捐献额  .通过query("查询条件来查找捐献人职业")

# 统计出现次数
df[‘party‘].value_counts()
# 多次分组，必须注意 by=[]，中的分组顺序。类似文件的树形结构

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# 1.读取文件usa_election.txt, 2.查看文件样式及基本信息
usa_election = pd.read_csv(‘./data/usa_election.txt‘)
usa_election.head(2)
# 3.【知识点】使用map函数+字典，新建一列各个候选人所在党派party
usa_election[‘parties‘] = usa_election[‘cand_nm‘].map(parties)
usa_election.head(2)
# 4.使用np.unique()函数查看colums：party这一列中有哪些元素
usa_election.parties.unique()
# 5.使用value_counts()函数，统计party列中各个元素出现次数，value_counts()是Series中的，无参，返回一个带有每个元素出现次数的Series
usa_election.parties.value_counts()
# 6.【知识点】使用groupby()函数，查看各个党派收到的政治献金总数contb_receipt_amt
usa_election.groupby(by=‘parties‘).contb_receipt_amt.sum()
# 7.查看具体每天各个党派收到的政治献金总数contb_receipt_amt 。使用groupby([多个分组参数])
usa_election.groupby(by=[‘contb_receipt_dt‘, ‘parties‘])[‘contb_receipt_amt‘].sum()
# 8.将表中日期格式转换为‘yyyy-mm-dd‘。日期格式,通过函数加map方式进行转换
date = usa_election.contb_receipt_dt
def transformDate(data):
    for i in range(len(date)):
        new_date = {}
        day, month, year = date[i].split(‘-‘)
        month = months[month]
        return ‘-‘.join([‘20‘+year, str(month), day])

usa_election[‘contb_receipt_dt‘] = usa_election.contb_receipt_dt.map(transformDate)
usa_election.head(2)
# 9.得到每天各政党所收政治献金数目。 考察知识点：groupby（多个字段）
usa_election.groupby(by=[‘contb_receipt_dt‘, ‘parties‘]).contb_receipt_amt.sum()
# 10.查看老兵(捐献者职业)DISABLED VETERAN主要支持谁 ：查看老兵们捐赠给谁的钱最多
df = usa_election[usa_election.contbr_occupation ==‘DISABLED VETERAN‘]
df.groupby(by=‘cand_nm‘).contb_receipt_amt.sum()
# 11.找出各个候选人的捐赠者中，捐赠金额最大的人的职业以及捐献额 .通过query("查询条件来查找捐献人职业")
max_amt = usa_election.groupby(by=[‘cand_nm‘])[‘contb_receipt_amt‘].max()
max_amt

for i in range(max_amt.size):
    max_money = max_amt[i]
    # for 循环中不显示执行结果，需要使用display或者print
    display(usa_election.query(‘contb_receipt_amt == ‘+str(max_money))

python 数据分析三剑客

原文：https://www.cnblogs.com/yx12138/p/11585833.html