如何使用Python进行数据分析【新手必看、高手备查】_怎么用python进行数据分析

一、Python语言及工作环境准备

（一）数据分析基本概念

1.数据分析的定义

数据分析是用统计分析方法对收集来的大量数据进行分析，提取有用信息和形成结论，对数据加以详细研究和概况总结的过程

2.数据分析应该具备的基本知识：

(1)计算机知识；(2)数学和统计知识；(3)行业知识。

（二）数据分析的流程

(1)明确目的：要解决什么问题，从哪些角度分析问题，采用哪些方法或者指标
(2)数据获取：本地数据采集和网络数据获取
(3)数据解析：把杂乱无章的数据处理成一定结构、有效数据的过程。
(4)数据分析：对数据进行分析操作，比如，分组和聚合操作
(5)结果呈现：将数据以图的形式直观的进行展示

（三）数据类型

数据分析的数据类型包括
(1)数值型：长度、宽度、评分。方法：极值、分位点、均值、标准差、变量相关性
(2)有序型：等级（A、B、C）。空气质量——数据之间有层级关系
(3)类别型：性别----组别之间没有好坏区分。方法：统计分布、直方图
(4)噪声数据：缺失值、重复值、无效数据。方法：数据清洗、统计分布（极个别数据大概率数据为噪声数据）

二、本地数据的采集与操作

（一）TXT文件操作

1.转义字符：’\n’
2.读操作：readline:以换行符”\n”为结点，逐行读取；readlines：读取全部内容，返回列表，列表中的每个元素都是行内容
3.write：将字符内容写入文件
4.writelines：将列表中的内容写入文件
5.关闭文件：close
1
2
3
4
5

（二）JSON文件操作

JSON数据有两种结构：
1.对象(object)：由 { } 表示，如 {key1:val1, key2:val2}
2.数组(array)：由 [ ] 表示，如 [val1, val2, …, valn]
3.读操作
从文件读取：json.load（）
从字符串变量读取：json.loads（）
4.写操作
写入文件：json.dump（）
写入字符串变量：json.dumps（）
1
2
3
4
5
6
7
8
9

（三）CSV文件操作

1.读操作：df_obj = pd.read_csv()：从CSV文件中读取数据，返回DataFrame类型的数据
2.写操作：df_obj.to_csv()：将数据写入CSV文件中，index=False，则表示不写入索引列，index=True，表示写入索引列
1
2

（四）Excel文件操作

1.读取文件：pd.read_excel()，参数sheet_name：工作簿的索引号，可以是单个工作簿或多个工作簿
2.写入文件
（1）写入单个工作簿：pd.to_excel()
（2）写入多个工作簿：
writer = pd.ExcelWriter(file.xlsx)
df1.to_excel(writer,Sheet_name)
writer.save()
1
2
3
4
5
6
7

（五）数据库及SQL常用语法

常见的数据库：

1. MySQL
2. PostgreSQL
3. Microsoft SQL Server
4. Oracle
5. MongoDB
6. SQLite

 - Create-插入
INSERT INTO  table_name(column1,column2,column3,...) VALUES(value1,value2,value3,...)
 - Read-查询、读取
SELECT column_name,column_name FROM table_name
3.SELECT * FROM...查询所有列
4.Update-更新
UPDATE table_name SET column1=value1，column2=value2，...WHERE some_colume=some_value
5.Delete-删除
DELETE FROM table_name WHERE some_column=some_value
1
2
3
4
5
6
7
8
9

（六）数据库基本操作

1.连接数据库

import sqlite3
db_path = './files/test.db'
conn = sqlite3.connect(db_path)
conn = sqlite3.connect(db_name)——获取访问数据库资源（db_name数据库路径）
如果db_name存在，读取数据库
如果db_name不存在，新建数据库
设置row_factory，对查询到的数据，通过字段名获取列数据
conn.row_factory = sqlite3.Row 
Tips：需要设置在conn.cursor()语句之前，若是不设置该语句，只能通过索引0,1,2...来获取内容
获取游标（访问数据库、操作数据库的资源，简单理解就是可以操作数据库）
conn.cursor()
用于执行SQL语句
一段私有的SQL工作区，用于暂时存放受SQL语句影响的数据
CRUD操作
cursor.execute(sql_str)——sql_str为数据库操作
cursor.executemany(sql_str)——操作多条数据
获取数据
获取单条记录：fetchone()
获取多条记录：fetchall()
获取前n条数据：fetchmany(n)
提交和关闭操作
提交操作：conn.commit()
关闭连接：conn.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.数据库多表连接

多表连接：查询记录时将多个表中的记录连接（join）并返回结果
join连接方式
1.交叉连接 (cross join)：生成两张表的笛卡儿积，返回的记录数为两张表的记录数的乘积
2.内连接 (inner join)：生成两张表的交集
3.外连接 (outer join)：
（1）left join (A,B)，返回表A的所有记录，另外表B中匹配的记录有值，没有匹配的记录返回null（左表记录保持不变，右表可以匹配则返回）
（2）right join (A,B)，返回表B的所有记录，另外表A中匹配的记录有值，没有匹配的记录返回null，但是目前在sqlite3中不支持右连接，可考虑交换A、B表操作，使用left join实现右连接的功能。

三、NumPy和SciPy介绍

• NumPy的特点（Numerical Python）
  import numpy as np
  a. 高性能科学计算和数据分析Python基础包，提供多维数组对象
  b. ndarray是多维数组对象，可以矢量运算（相量化操作）c. NumPy矩阵运算，无需循环
  d. 线性代数、随机数生成
• SciPy介绍：import scipy as sp
  a. SciPy在NumPy基础上增加了众多的数学、科学及工程常用的科学计算库函数
  b. 线性代数、常微分方程求解、信号处理、图像处理、稀疏矩阵
• NumPy数据结构：ndarray，N维数组对象（矩阵）
  a. ndim属性，维度个数（一维/二维/三维）
  b. shape属性，各维度大小
  c. dtype属性，数据类型
  d. axis()–轴
  dtype(int/float)
  

（一）多维数组创建方法

1.多维数组的创建

np.array(collection)–collection为序列型对象(list)，嵌套序列(list of list)

k = [1, 2, 3, 4, 5, 6]
data = np.array(k) # 一维数组
print(data)
zeros_arr = np.zeros((3, 4))# 第一个参数是元组，用来指定大小，如（3，4）
ones_arr = np.ones((2, 3))
rand_arr = np.random.rand(4, 5)
arr = np.arange(10) # 类似range函数生成等差数列
arr = np.arange(10)
print(arr)
arr1 = arr.reshape(5,2) # 转换数组形状
print(arr1)
arr1 = arr.astype(float)  
print(arr1.dtype) # 转换数据类型

np.random.rand() # 生成指定形状的随机数组
np.arange() # 类似range函数，生成等差数组序列
reshape() # 转换形状
astype() # 转换数据类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.ndarray多维数组对象

n维数组对象，可以表示N维数据
np.array()–创建一个ndarray数组对象
np.arange(n)–创建一个元素个数为n的ndarray数组对象
ndim属性–维度的个数

（二）多维数组操作方法

• 索引切片

特征：左闭右开
如：arr[1,1]等价于arr[1][1]
arr[1:3,1:3]，起始包括第二行，第二列，结尾不包括第三行，第三列

• 转置

多维数组arr的行变列，列变行
如：arr为2行3列的多维数组，则arr.T为3行2列的多维数组
np.transpose()
交换轴位置 np.swapaxes(a,0,1)–交换轴方向（维度较高）

0是行的方向
1是列的方向

（三）Numpy的常用方法

• 常用的统计方法：
  np.mean：求均值
  np.sum：求和
  np.max：求最大值
  np.min：求最小值
  np.std：求标准差
  np.var：求方差
  np.argmax()：求最大值索引（位置）
  np.argmin()：求最小值索引
  np.cumsum()：求累加
  np.cumprod()：求累乘
• 常用方法：
  是否所有元素满足条件：np.all()
  是否至少一个元素满足条件：np.any()
  求唯一值并返回排序结果：np.unique()
• 注意
  默认是全部维度统计；多维数组需要指定统计维度

（四）数据分析工具Pandas基础

1.数据结构–Series

类似一维数组的对象

构建Series：数组、列表、dict
index：索引（位置编号，根据索引） name、Value

pd.Series(range(10, 20))
d = {'a' : 0., 'b' : 1., 'c' : 2.}
pd.Series(d)
pd.Series(np.random.rand(5), index=['a', 'b', 'c', 'd', 'e']) # 构建时指定索引
1
2
3
4

预览数据

ser_obj.head()
ser_obj.tail()
1
2

数据和索引组成

索引在左，数据在右

ser_obj.index  #获取索引
ser_obj.values  #索引的值
1
2

索引自动创建

获取数据和索引

ser_obj.index
ser_obj.values
1
2

name 属性–ser_obj.name

ser_obj = pd.Series(np.random.rand(100), name='rand_num')
ser_obj.name
ser_obj.index.name = 'index'
1
2
3

通过索引获取数据

ser_obj2 = pd.Series(np.random.rand(5), index=['a', 'b', 'c', 'd', 'e']) # 通过索引名(字符串)获取数据
ser_obj2['b']
ser_obj2.loc['b']  # 位置
'a' in ser_obj2 # 通过in判断数据是否存在
ser_obj2.iloc[0]
1
2
3
4
5

处理缺失数据

numbers = [4, 5, 6, None]
pd.Series(numbers)
1
2

2.数据结构

类似多维数组/表格数据（如：Excel）
每列数据可以是不同类型
索引包括行索引（index）和列索引（label/column）

构建DataFrame

array = np.random.randn(5, 4) # 通过ndarray创建
df_obj = pd.DataFrame(array)

dict_data = 
{'A': 1., 
'B': pd.Timestamp('20190101'),
'C': pd.Series(1, index=list(range(4)), dtype='float32'),
'D': np.array([3] * 4, dtype='int32'),
'E' : ['Python', 'Java', 'C++', 'C#'],
'F' : 'ChinaHadoop' } # 通过dict
df_obj2 = pd.DataFrame(dict_data)  #广播操作
				
df_obj[label]或df_obj.label # 通过列索引获取列数据（Series型）
df_obj2.columns
df_obj2.index
df_obj2.values
df_obj2['E']
df_obj[new_label]=data # 增加列数据，类似dict添加key-value
df_obj2['G'] = range(4)
df_obj2.drop(columns=['B', 'G'])

df_obj.dorp(columns=[]) # 返回值是操作结果，原数据不变
del df_obj[col_idx] # 删除列
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.数据结构—index

• Series和DataFrame中的索引都是Index对象，是索引数据获取数据的方式
  不可变（immutable），保证数据安全
  常见的Index类：index、int64index、Multilndex–层级索引、Datetimeindex–时间戳类型
• 重置索引 reset_index(drop)，将索引重新赋值0-1
  参数drop，为True丢弃原来的索引列，默认False

ser_obj.reset_index() # 重置索引，生成DataFrame
ser_obj.reset_index(drop=True) # 使用drop重置索引
1
2

4.Series的索引操作

• Series的索引操作

ser_obj = pd.Series(range(5), index=['a', 'b', 'c', 'd', 'e'])
ser_obj['label'] # 行索引
ser_obj['b']
ser_obj.loc['c']
ser_obj[4]
ser_obj.iloc[1]
ser_obj[pos]
1
2
3
4
5
6
7

• 切片索引

ser_obj[2:4]
ser_obj['label1':label3]
ser_obj['b':'d'] #注意：按索引名切片操作，是包含终止索引的
1
2
3

• 不连续索引

ser_obj[['label1','label2','label3']]
ser_obj[[0, 2, 4]]
ser_obj[[pos1,pos2,pos3]]
ser_obj[['b', 'd']]
1
2
3
4

5.DataFrame的索引操作

• DataFrame的索引操作
• 构建DataFrame

country1 = pd.Series({'Name': '中国',
			                    'Language': 'Chinese',
			                    'Area': '9.597M km2',
			                     'Happiness Rank': 79})
country2 = pd.Series({'Name': '美国',
			                    'Language': 'English (US)',
			                    'Area': '9.834M km2',
			                     'Happiness Rank': 14}
country3 = pd.Series({'Name': '澳大利亚',
			                    'Language': 'English (AU)',
			                    'Area': '7.692M km2',
			                     'Happiness Rank': 9})
df = pd.DataFrame([country1, country2, country3], index=['CH', 'US', 'AU'])
df_obj['label'] # 列索引
df['Area']

df_obj[['label1','label2']] # 不连续列索引
df[['Area', 'Name']]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 行索引和Series类似：.loc[ ] .iloc[ ]
• 混合索引：先行后列，先列后行

print(df.loc['CH']['Area']) # 先行后列
print(df.iloc[1]['Area'])
print(df['Area']['CH']) # 先列后行
print(df['Area'].loc['CH'])
print(df['Area'].iloc[0])
1
2
3
4
5

# Pandas中的很多操作都有参数inplace，如drop（），replace（）
df.drop('Area', axis=1) # 删除列，对原数据不产生影响，需要新增变量接收，默认inplace=False，表示将操作后的结果进行返回，对原数据不会产生影响（需要有变量接收）
df2 = df.drop('Area', axis=1)，inplace=True，没有返回值，在原数据上进行操作，对原数据会产生影响（同时没有返回值）
df.drop('Area', axis=1, inplace=True) # 对原数据产生影响，返回None
1
2
3
4

6.索引操作总结

• Pandas的索引（三种）
  .loc–行索引，Series或Pandas
  .iloc–位置索引，接收整型位置
  常用于行索引
• 注意
  DataFrame索引时可以看作多维数组ndarray操作
  标签的切片索引是包含收尾位置
• 布尔值遮罩（Boolean Mask）
  

df['Language'].str.contains('English') # 找出说英语的国家,字符串包含English，向量化的字符串操作，返回布尔值
 # 生成布尔值遮罩
filter_condition = df['Language'].str.contains('English')
df[filter_condition] # 写法语句表达意思一致
df[df['Happiness Rank'] <= 20] # 过滤出排名前20的国家
1
2
3
4
5

7.运算与对齐

Pandas可以对不同索引的对象进行算术运算
索引和数据的对应关系仍保持在数组运算结果中
如果没对齐的位置补NaN
Series间运算（对应相同索引值进行计算，之后数据为空）

# DataFrame间的运算
df1 = pd.DataFrame(np.ones((2, 2)), columns=['a', 'b'])
df2 = pd.DataFrame(np.ones((3, 3)), columns=['a', 'b', 'c'])
df1 + df2
1
2
3
4

• Series和DataFrame间的运算
  总结
  对于Series，对齐操作会发生在索引上
  对于DataFrame，对齐操作会同时发生在行和列上
  Series和DataFrame操作，Series被看作行数据（index）
  DataFrame中的每行数据进行计算

8.函数应用操作（Map）

函数应用

1.将函数作用于一个Series的每一个元素
2.类似于Python的高阶函数map（）
3.函数可以是Numpy中的通用函数，也可以是自定义函数
4.优点：不使用循环，代码简洁，效率高

l = list(range(10))
result = map(math.sqrt, l)
对l中的每个元素开根号，map是高阶函数，l是应用列表.使用map操作，只是map对象，记录操作过程
list(result)–注意直到取出结果，才会执行操作

ser = pd.Series(l)
ser.map(np.sqrt)--开根号
ser.map(lambda x: x**2 + 1)--自定义函数
1
2
3

9.函数应用操作（apply，applymap）

• apply与applymap区别，可以应用于DataFrame对象
  apply（）可以将函数应用到行或列上
  DataFrame上操作时注意指定轴的方向，默认axis=0
  applymap（）函数应用于每个数据
  

df = pd.DataFrame(np.arange(10).reshape(5, 2),columns=['col_1', 'col_2'])
df.apply(np.sum)
df.applymap(np.sqrt)
1
2
3

10.文件读写操作

pd.read_csv(filepath,usecols,index_col) # 读取数据
filepath：文件路径
usecols：指定需要读取的列（默认全部读取）
index_col：指定某列为索引列，默认会生成一列索引
df.info（）# 快速查看数据基本信息
df.to_csv(filepath，index) # 保存数据
filepath：保存的路径
index：是否将索引列保存，默认为True

文件路径：
filepath = './datasets/2016_happiness.csv'
data = pd.read_csv(filepath, usecols=['Country', 'Region', 'Happiness Rank', 'Happiness Score'])

data.head()--数据预览
data.info()--查看数据基本信息
data['int_score'] = data['HappinessScore'].apply(np.around)
# 使用apply函数，生成一列打分的整数部分列（四舍五入）
data.to_csv('./datasets/2016_with_index.csv')
data.to_csv('./datasets/2016_no_index.csv',index=False)区别index参数的使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

11.排序操作

filepath = './datasets/2016_happiness.csv',
data = pd.read_csv(filepath, usecols=['Country', 'Region', 'Happiness Rank', 'Happiness Score'],index_col='Happiness Rank')

索引排序，sort_index(  )
data.sort_index(ascending=True).head(10) # 升序排序
data.sort_index(axis=1).head() # 按列名排序，默认axis=0

对DataFrame操作时注意轴方向
按值排序，sort_values(by,ascending)

按单列的值排序
data.sort_values(by='Country').head(10) # 单列排序
data.sort_values(by=['Region', 'Country']).head(10) 

多列排序
by='label'
ascending：True 升序，Fales降序
data.sort_values(by=['Region', 'Country'], ascending=[True, False]).head(10)

按值排序，sort_values(by,ascending)
按多列的值排序，by=[  ]，ascending=[  ]--先按第一个元素排序，再按第二个排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

四、数据清洗

（一）数据清洗

数据清洗：数据分析关键一步，直接影响之后的工作
读取数据

filepath = './datasets/log.csv'
log_data = pd.read_csv(filepath)
log_data
1
2
3

操作：1.缺失值；2.log_data.isnull() --针对每一个值判断是否存在缺失；3.重复值；4.无效值；5.处理缺失数据；6.判断是否存在缺失值

ser_obj.isnull() 
log_data.isnull().any() # 判断哪些列有空值
df_obj.isnull()
log_data.isnull().any(axis=1) # 按行排序
1
2
3
4

可以结合any()判断行/列中是否存在缺失值

dropna（）
# 丢失缺失数据，注意inplace参数,inplace=True在原始变量操作
log_data.dropna() # 只要有一行存在缺失数据，就直接去掉
log_data.dropna(subset=['paused']) # 如果这一列有空值
fillna（）# 填充缺失数据
log_data.fillna(-1) # 填充-1
1
2
3
4
5
6

对数据进行排序

sorted_log_data = log_data.sort_values(by=['time', 'user'])
sorted_log_data.head()
df.ffill（）# 按之前数据填充
sorted_log_data.ffill()  # 按照之前数据填充，在填充前需要对数据进行排列
df.bfill（）# 按之后数据填充
sorted_log_data.bfill() # 项目中使用ffill（）或bfill（），注意数据排列顺序
1
2
3
4
5
6

（二）数据清洗—处理重复数据

1.处理重复数据

data.duplicated() # 判断是否存在重复数据
duplicated(subset)返回布尔型Series表示每行是否为重复行
data.duplicated(subset=['age', 'surname'])
drop_duplicates（subset，keep）过滤重复行
默认判断全部列，可通过参数subset指定某些列
keep，默认（first）保留第一次出现的数据，last保留最后出现的数据
data.drop_duplicates(subset=['age', 'surname'])
data.drop_duplicates(subset=['age', 'surname'], keep='last')
1
2
3
4
5
6
7
8

2.替换数据

replace（to_replace）# 替换数据
data.replace(0, 100) # 参数to_replace为需要被替换的值，数值、字符串
data.replace([0, 1, 2, 3], [4, 3, 2, 1])	# 列表
data.replace([0, 1, 2, 3], 4)
data.replace({0: 10, 1: 100}) # 字典
1
2
3
4
5

五、常用统计方法

（一）describe/quantile

describe（），快速查看每列数据的统计信息
count–数据个数
mean–均值
std–标准差
min–最小值
25%–第1四分位数，即第25百分位数
50%–第2四分位数，即第50百分位数
75%–第3四分位数，即第75百分位数
max–最大值
data.describe()–只对数值型数据做统计
四分位数

quantile（q）# 输出指定位置的百分位数，默认q=0.5
data.quantile(q=0.5)
data.quantile(q=0.25)
1
2
3

（二）sum、mean、median、count

• sum（）-求和–data.sum() #user字符串加法相当于字符串拼接 paused中false为0，true为1
• mean（）-求均值–data.mean()
• median（）-中位数–data.median()
• count（）-求非空个数–data.count()
• 不对缺失数据进行统计

（三）max、min、idxmax、idxmin

data.max() # max（）-最大值
data.min() # min（）-最小值
data['Happiness Score'].idxmax() # idxmax（）-返回最大值对应索引
data['Happiness Score'].idxmin() # idxmin（）-返回最小值对应索引
# argmax（）和argmin（）在近期版本中将停止使用
1
2
3
4
5

（四）mad、var、std、cumsum

• mad（）-平均绝对误差-表示各个变量值之间差异程度数值
• var（）-方差
• std（）-标准差
• 方差标准差描述变量离散程度
• cumsum（）-累加

五、数据分析工具Pandas高阶

（一）层级索引

1.Multilndex对象

设置多个索引列：
set_index[‘a’,‘b’],inplace=True，注意a、b先后索引
选取子集
外层选取 loc[‘out_index’]–data.loc[‘Western Europe’]
内层选取 loc[‘out_index’,‘inner_index’]–data.loc[‘Australia and New Zealand’, ‘New Zealand’]

举例：

（1）先访问到bar，再访问one、two
交换层级顺序 swaplever（）–data.swaplevel()
层级索引排序 sort_index（level=）–data.sort_index()–data.sort_index(level=)
（2）常用语分组操作、透视表的生成
知识要点：
层级索引：层级索引的对象是MultiIndex对象
设置多个索引列：
set_index([‘a’,’b’],inplace=True)，其中a的列是第一级行索引，在最外层，b的列设置为第二级行索引，在次外层的位置，a和b的先后顺序是有意义的。
选取子集：
外层选取loc[‘outer_index’]，outer_index指外层索引中指定索引行的名称，比如行索引country为[“A”,”B”,”C”,”D”]，则loc[“B”]表示获取索引行为B的分组数据
内层选取loc[“outer_index”,”inner_index”]，表示从外层索引为outer_index的分组中选取内层索引行为inner_index的分组数据。

（二）分组与聚合操作

分组：对数据集进行分组，然后对每组数据进行统计分析
1.pandas利用groupby进行更加负责的分组运算
2.分组运算过程 split-apply-combine
拆分：进行分组的数据
应用：每个分组运行的计算规则
合并：把每个分组的计算结果合并起来

groupby在X上分组
1.聚合：数组产生标量的过程，如：mean（）、count（）等
2.常用于对分组后的数据进行计算，内置的聚合函数：sum()、mean()、max()、min()、count()

知识要点
1.分组：对数据集进行分组，然后对每组数据进行统计分析
2.分组运算的基本原理:
split->apply->combine
(1)拆分：进行分组的根据
(2)应用：每个分组进行的计算规则
(3)合并：把每个分组的计算结果合并起来

聚合：
1.数组产生标量的过程，如mean()、count()…
2.常用于对分组后的数据进行计算
3.内置的聚合函数：sum()，mean()，max()，count()

1.分组操作

obj.groupby('label')--obj1 = data.groupby('Region') # 按单列分组 
obj.groupby(['label1','label2'])--obj2 = data.groupby(['Region', 'Country']) # 按多列分组
1
2

多层dataframe（运行为中间数据）–运行结果为DataFrameGroupBy对象
1.groupby（）操作后产生Groupby对象：
2.DataFrameGroupBy
3.SeriesGroupBy
4.GroupBy对象没有进行实际运算，只包含分组的中间数据
5.对GroupBy对象进行分组聚合操作
常用的聚合操作：mean() sum() size() count()
非数值数据不进行分组运算

DataFrame可以进行两种方式的分组:
1.按单列分组，obj.groupby(‘label’)
2.按多列分组，obj.groupby([‘label1’,’label2’])，先按照label1分组，再按照label2分组
注意：
groupby()操作后仅产生GroupBy对象，而不进行实际运算，只有进行聚合操作后，才对分组后的数据进行聚合运算，常见的聚合操作:mean()，sum()，size()，count()–非空个数

2.分组操作（自定义分组及聚合操作）

自定义分组

# 方法1:groupby（）可以传入自定义函数进行分组，操作针对的是索引
data2 = data.set_index('Happiness Score')
data2.groupby(get_score_group).size()
# 方法2:项目中，通常可以先认为构造分组列，然后再进行分组groupby（常用）
data['score group'] = data['Happiness Score'].apply(get_score_group)
data.groupby('score group').size()
1
2
3
4
5
6

自定义聚合操作

data.groupby('Region')['Happiness Score'].agg([np.max, np.min, np.mean]) 
1

使用agg（）函数
传入包含多个函数的列表
传入包含多个函数的列表，可同时完成多个聚合操作

 >可通过字典为每个列指定不同的操作方法
data.groupby('Region').agg({'Happiness Score': np.mean, 'Happiness Rank': np.max})
data.groupby('Region')['Happiness Rank'].agg(max_min_diff) # 传入自定义函数
1
2
3

（三）透视表操作

透视表（pivot table）介绍：计算、汇总、分析数据的强大工具
1.包括分组、统计操作
可以将扁平（行、列）的表转换为立体表（行、列、值）的过程

df.groupby(by=['Semester', 'Subject'])['Score'].mean().to_frame()
1

1.透视表（pivot table）操作

df.pivot_table(values、index、columns、margins)
df.pivot_table(values=‘Score’, index=‘Semester’, columns=‘Subject’, aggfunc=np.sum)
values：透视表中的元素值（根据聚合函数得出）
index：透视表的行索引
columns：透视表的列索引
aggfunc：聚合函数，可以指定多个函数
margins：表示是否对所有数据进行统计

df.pivot_table(values='Score', index='Semester', columns='Subject', margins=True, aggfunc=np.sum)
cars_df.pivot_table(values='(kW)', index='YEAR', columns='Make') # 比较不同厂商电池方面不同
1
2

2.数据合并 concat

按照指定的轴方向对多个数据对象进行数据合并
pd.concat(objs,axis)
objs 多个数据对象，包含DataFrame的列表
axis：0按索引方向（纵向），1按列方向（横向）
注意：默认使用outer join 合并

3.数据连接 merge

merge
根据单个或多个键将不同DataFrame的行连接起来
默认将重叠列的列名作为“外键”进行连接
on显示指定外键
left_on 左侧数据的外键
right_on 右侧数据的外键

4.数据重构stack（堆叠）、unstack（平铺）

适用于层级索引对象
stack（）：数据的列旋转为行
参数level：索引的层级，默认为-1，表示最里面的一层索引
unstack（）：将数据的行旋转为列（只对数据重构）

六、数据可视化

1.探索性数据分析EDA介绍

探索性数据分析（Exploratory Data Analysis）
知识要点
探索性数据分析(Exploratory Data Analysis, EDA)：1977年John Wilder Tukey第一次系统性地论述了探索性数据分析

2.EDA介绍

1.注重对数据进行概括性的描述，不受数据模型和科研假设的限制
2.EDA是指对已有的数据通过作图、制表、计算特征等手段探索数据的结构和规律的一种数据分析方法
3.适用于当对数据中的信息没有足够的经验，不知道该用何种传统统计方法进行分析时
4.“free style”的形式

3.EDA的目的

a.通过可视化对数据构建初始认知
b.论证该使用何种统计推断进行分析
c.通常情况，对于未知的数据集先进行EDA

4.EDA 和 CDA的对比

验证性数据分析（Confirmatory Data Analysis, CDA）：注重对数据模型和假设的验证
CDA：confirmatory Data Analysis
a.从假设开始
b.侧重于对假设的验证
c.使用统计模型
d.有既定的策略、方法
EDA：
a.开始没有假设
b.侧重于探索和生成假设
c.通常使用可视化的方法
d.没有统一的步骤、形式

5.EDA常用工具

EDA常用工具：散点图、直方图、柱状图、线型图、盒形图

七、数据可视化

（一）Matplotlib绘图基本介绍

• Matplotlib介绍
创建出版质量图表的绘图工具库
目的是为Python构建一个Matlab式的绘图接口
import matplotlib.pyplot as plt
python模块包含了常用的matplotlib API 函数
使用Numpy进行数值运算和表示
• Matplotlib绘图步骤
Matplotlib基本元素：元素、函数、画布（figure）和坐标轴（axes）、绘图过程
变量和函数通过改变figure和axes中的元素（如：title、label）一起描述figure和axes

（二）Matplotlib画布

Matplotlib图像位于figure对象中
通过plt.figure()创建
如果没有指定创建，matplotlib会自动生成默认画布
参数figsize控制画布大小，单位inch
plt.show（）显示绘图结果

（三）散点图和柱状图的绘制

plt.scatter(x, y, s, c, marker) # 散点图
x 横轴的数据 
y 纵轴的数据
s 点的大小，标量或数组
c 点的颜色，标量或数组
marker 点的样式
其中：标量：同时所有的点的大小（颜色）；数组：为每个点设置不同的大小（颜色）
颜色配置： https://matplotlib.org/api_as_gen/matplotlib.pyplot.colors.html
点的样式： https://matplotlib.org/api/markers_api.html

plt.bar(x, height, color) # 柱状图
x 柱子的横坐标
height 柱子的高度（数据）
color 柱子的颜色
注意：绘制多组柱状图时，需要设置不同的横坐标，避免重叠
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（四）直方图的绘制

plt.hist(x, bins, rwidth ) # 直方图形式类似于柱状图 ，通过将数据组合在一起来显示分布，比如：显示各年龄段的数据个数
x 数据
rwidth 柱子宽度比例，默认为1
bins 分组的个数或分组边界，如4或[20, 30, 40, 50, 60]
除了最后一组，其余组的右边界是开放的[20, 30), [30, 40), [40, 50), [50, 60]
1
2
3
4
5

（五）矩阵绘图

plt.imshow(X, cmap) # 矩阵绘图通过可视化的方式呈现矩阵数据，可用于显示三维信息
X 矩阵数据（二维数组）cmap 颜色主题
plt.colorbar() 为图像添加颜色条
https://matplotlib.org/users/colormaps.html
1
2
3
4

（六）子图的使用

plt.subplots(nrows, ncols, sharex, sharey) # 绘制子图
nrows, ncols # 分割的行数和列数
sharex, sharey # 是否共享x轴、y轴，默认是false，返回新创建的figure和subplot数组
1
2
3

（七）Matplotlib颜色、标记、线型

plt.plot(x, y, fmt) 绘制折线图
 x, y 横轴纵轴数据
fmt 颜色 标记 线型的样式
如 r.-- 表示 红色 点标记 虚线
1
2
3
4

（八）Matplotlib坐标刻度、标签、图例、标题

设置刻度范围
plt.xlim(), plt.ylim() 
ax.set_xlim(), ax.set_ylim()
设置显示的刻度
plt.xticks(), plt.yticks() 
ax.set_xticks(), ax.set_yticks()
设置刻度标签
如果使用plt设置刻度标签，需要使用 
plt.xticks(), plt.yticks()进行配置
ax.set_xticklabels(), ax.set_yticklabels()
设置坐标轴标签
ax.set_xlabel(), ax.set_ylabel()
设置标题
plt.title()
ax.set_title()
图例
1.绘制图形时，使用label参数
ax.legend(loc), plt.legend(loc)
loc=‘best’自动选择放置图例最佳位置
中文显示
1.使用rcParams属性进行配置
2.
a.指定默认字体
matplotlib.rcParams['font.sans-serif'] = ['SimHei’]
b.解决保存图像是负号'-'显示为方块的问题
matplotlib.rcParams['axes.unicode_minus'] = False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

（九）Seaborn介绍

Seaborn是Python中的一个制图工具库
在Matplotlib上构建，支持numpy和pandas的数据结构可视化
Seaborn比Matplotlib更简洁易用
特点
a.多个颜色主题
b.可视化单变量、二维变量用于比较数据集中各变量的分布情况
c.可视化线性回归模型中的变量
d.可视化矩阵数据，通过聚类算法探究矩阵间的结构
e.可视化时间序列数据及不确定性
f.可在分割区域制图，用于复杂的可视化

 import seaborn as sns
1