数据分析三剑客
前言
大数据时代，数据的重要性不言而喻，掌握数据者得天下。很多同学可能对一堆数据不知如何进行处理分析得到有用的信息，本文主要基于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)
- axis=0：表示针对行进行计算或排序，列有序
- 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)
- 默认格式：dtype: int64
- Series之间的运算，自动对齐不同索引的数据，如果索引不对应，则补NaN
2. DataFrame
1. DataFrame简介
- DataFrame是一个【表格型】的数据结构。DataFrame由按一定顺序排列的多列数据组成。设计初衷是将Series的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。
- 行索引：index
- 列索引：columns
- 值：values
2. 创建DataFrame
- 最常用的方法是传递一个字典来创建。DataFrame以字典的键作为每一【列】的名称，以字典的值（一个数组）作为每一列。
- 此外，DataFrame会自动加上每一行的索引。
- 使用字典创建的DataFrame后，则columns参数将不可被使用。
- 同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()级联
- axis=0/1
- join='outer'/'inner'
- 不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致。有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()合并
- 一次只能用于两张表，用于数据的整合
- 参数说明
- left， right，
- how='inner/outer/left/right'
- 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=
# 指定单值替换，原数据为：64.0
df.replace(to_replace={64:'xxx'})
# 指定第三列的6替换
df.replace(to_replace={2:6}, value='six')
2. map()：映射
- 映射关系表：dict={}
- map()函数：新建一列，map函数并不是df的方法，而是series的方法
- map()可以映射新一列数据
- map()中可以使用lambd表达式
- 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. 分组
- 数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。
- 数据分类处理
- 分组：先把数据分为几组
- 用函数处理：为不同组的数据应用不同的函数以转换数据
- 合并：把不同组得到的结果合并起来
- 数据分类处理的核心
- 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))
☞☞☞ 古人学问无遗力，少壮工夫老始成。纸上得来终觉浅，绝知此事要躬行。 ☜ ☜ ☜
