数据分析笔记

数据分析

---

1、不同数据格式读取

---

• mysql数据操作
• text文件操作
• json文件操作
• csv文件操作
• excel文件操作

1.1 mysql 数据操作

---

# pip intall pymysql

import pymysql

pymysql.connect()   # 此对象为pymysql连接数据库的类

# 创建Connection连接对象实例
conn = pymysql.connect(host='localhost', port=3306, user='root', password='mysql', database='python1', charset='utf8')
# 创建游标
cursor = conn.cursor()
# 数据查询
sql = "select id,name from students where id = 7"  
# 数据更新
sql = 'update students set name="刘邦" where id=6'
# 数据删除
sql = 'delete from students where id=6'
# 载入查询语句, 返回的是执行成功的条数，可以用于判断是否执行成功
cursor.execute(sql)
# 接收查询结果、就要一条
result = cursor.fetchone()
# 关闭游标
cursor.close()
# 关闭连接
conn.close() 
 
# 数据更新/或数据新增时
conn.commit()   # 提交
# 事务的回滚  
conn.rollback()

# 查看所有数据 
cursor.fetchall()
cursor.fetchone()
cursor.fetchmany(2)

1.2 TEXT 文件读取

---

参数说明 ：

• filename ：文件名称
• mode ：文件打开方式。
  • r : read只读模式
  • w ：writer写入模式
  • a ： append追加方式
• encodeing ： 指定文件解码 （当文件中文乱码时，则可以指定编码为 utf-8解决）

#文件打开
with open (filename,mode,encoding=None) as f :
    
    # 文件的读取
	file.read()   #  <class 'str'>
	file.readline()   # 读取一行   <class 'str'>
	file.readlines()   # 读取多行，返回列表模式   <class 'list'>
 		
	# 写入文件
	file.write("写入内容")   # 返回 写入内容的字符串个数

	# 文件的关闭
	file.close()

1.3 JSON 操作

---

• json.dumps() ：将python对象编码转化为字符串（将字典形式的数据转化为字符串）
• json.dump() ：将python对象转化为 Json 存储到文件中
• json.loads() ：将 Json 字符串编码成python对象（将字符串形式的数据转化为字典）
• json.load() ：将文件中的 Json的格式转化为 python对象提取出来

import json
 
dict1 = {'A': 'a', 'B': 'b', 'C': 'c'}
print(type(dict1))
print(dict1)
 
# json.dumps(content) : 将python对象转化为 <class 'str'>
en_json = json.dumps(dict1)
print(type(en_json))
print(en_json)
 
#  json.loads(content) ：将字符串转化为 python对象  <class 'dict'>
de_json = json.loads(en_json)
print(type(de_json))
print(de_json)
 
#  eval()解析json
dict2 = {'X': 'x', 'Y': 'y', 'Z': 'z'}
en_json = json.dumps(dict2)
de_json = eval(en_json)
print(type(de_json))
print(de_json)



# 运行结果

<class 'dict'>
{'A': 'a', 'B': 'b', 'C': 'c'}
<class 'str'>
{"A": "a", "B": "b", "C": "c"}
<class 'dict'>
{'A': 'a', 'B': 'b', 'C': 'c'}
<class 'dict'>
{'X': 'x', 'Y': 'y', 'Z': 'z'}

# json格式读取 - {"age":18 } 
with open("data.json",mode="r") as f:
	res = f.read()   #  {"age":18 } 
	print(type(res))	# 数据类型为 str
	
json.load(open("data.json",'r'))  #从文件中进行读取，并讲内容转化成字典格式,内容可以通过键值进行取值
json.loads()   # 从字符串变量读取

# json格式写入
s = 'json'
json.dump()   # 将python对象转化成 json对象     {"age":18 }  转化为   '{"age":18 }' 
json.dump(s,open('json.txt','w'))  # 将内容写入到json.txt文件中，
S = json.dumps({["内容"])  # 将传入的内容抓话成字符串，并不对文件进行操作
print(json.dumps(['lcl',{"age":19}]))

多行json数据压缩

# json格式转化
f = open("data/result.txt",encoding="utf-8")

# 压缩多行转化为一行
contenxt = json.dumps(f.read()).replace("\\n","").replace("\\","").replace(" ","")
contenxts = contenxt.replace("}{","}\n{")

1.4 CSV 格式操作

---

# CSV文件写操作
import csv
with open("demo.csv","w",newline = "") as datacsv:  #文件名、打开方式、新的一行默认为空
	csvwriter = csv.writer(datacsv,dialect =("excel"))  # 创建 CSV 写入对象 默认打开的方式EXCEL表格 
	csvwriter.writerow(["A","B","C","D"])  #插入对象,单行写入
	csvwriter.writerows([],[],[])  # 多行写入，每个[] 为一行

#CSV文件读取
with open("demo.csv",'r') as rf:
	reader = csv.reader(rf) # reader 是一个对象
	print(next(reader))
	for i in reader:
		print(i)

1.5 EXCEL 格式操作

---

• 文件读取 ：xlrd 库操作 excel
• 文件写入 ：xlwt库操作 excel
• openpyxl 操作 excle文件
• pandas 操作 excel文件

import xlrd   # openpyxl（只支持 2010版 以上 xlsx 文件）

#文件的读取
book = xlrd.open_workbook('1.xls')   #打开文件
sheet = book.sheet_by_index(0)  # 获取第一个sheet,sheet 是一个对象
print(sheet.nrows)  # 获取行数
print(sheet.cell(1,1))  # 根据列数、行数、获取内容值
print(sheet.row(1))  # 获取第一行
print(sheet.row_values(1,1))  #获取第一行，跳过第一列

#文件的写入     
import xlwt
wbook = xlwt.Workbook('写入文件名')      #写入文件名
wsheet = wbook.add_sheet("sheet1")   # 向sheet1 中进行写入
wsheet.write(1,0,label = 'Row 0,Column 0')  # 位置、label 是写入的内容
wsheet.write(0,1,label = 'Row 0,Column 1')
wbook.save('output.xls')   #写入后保存为


# 用 openpyxl 写入数据
# openpyxl（只支持 2010版 以上 xlsx 文件
from openpyxl import Workbook
wb = Workbook()  # 创建工作簿
ws = wb.catie	# 激活第一个工作表
# 构建数据
data = [
	["name","age","class"],
	["amy","18","25"],
	]
# data里面有多少个数据就以为着有多少行
for row in data:
	ws.append(row)
wb.save("demo.xlsx")	# 保存工作簿


# 用 openpyxl 读取数据
# openpyxl（只支持 2010版 以上 xlsx 文件
from openpyxl import load_workbook
wb = load_workbook("demo.xlsx")	  # 打开工作簿
ws = wb.cative	# 打开工作表
# 单元格的值
tuple(ws.rows)
for row in ws.rows:		# 循环出每一行
	for cell in ws.row:		# 循环出每一个单元格
		print(cell.value)	

        
        
# pandas  读取excel文件

import pandas as pd

# 读取
data = pd.read_excel("demo.xlsx",sheet_name=0)

# 写入
data.to_excel("demo.xlsx",index=Flase)

---

2、Numpy库

---

2.1 Numpy介绍

---

• 介绍 ： 数值计算的基础包，提供很多科学函数的处理功能，将数组对象作为数据交换的通用语言
• 特点 ：提供多维数组、提供算数操作及广播机制，对数据进行快速的矩阵计算，对硬盘中数据 进行读写操作

2.2 数据的创建与修改

---

# pip install numpy


# 数组创建  [1 2 3 4 5]
li = [1,2,3,4]
#可以通过指定dtype的方式指定创建数据的类型   order 创建数组样式，C为行方向、F为列方向，A为任意方向
a = np.array([1,2,3,4,5],dtype ="int32",copy = None, subok = False, ndmin = 0) 

a1 = np.array(li)
a2 = np.array(range(1,6))   #range (开始位、结束位、步长、类型)
a3 = np.arange(1,6) # arange 方式创建数组

# 创建二维数组 / 创建三维数组
t2 = np.array([[1,2,3],[4,5,6]])
t3 = np.array([[[1,2,3],[4,5,6],[7,8,9]]])


print(a.dtype) #打印数组中数据的类型 

a4 = np.array([1,0,1,1,0],dtype= bool)	# 创建指定类型的数组 （组内元素指定为bool类型）

a5 = a1.astype("float32")  # #修改数组中数据的类型为 float32 类型

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)   # 一维、等差数组  开始、结尾、步长
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)  # 等比例
numpy.empty(shape,dtype = float,order = "C")   #创建数组   
numpy.zeros(shape, dtype = float, order = 'C')  # 创建指定大小数组、数组元素用0来填充
numpy.ones(shape, dtype = None, order = 'C')   #创建为 1 的数组
numpy.asarray(a, dtype = None, order = None)   # 创建数组
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)   # 动态数组  buffer流式数据读取

# python中的方法 - b数组保留2位小数- 四舍五入的方式
print(np.round(b,2))
# numpy 中的方法 - b数据保留3位小数
print(np.around(b,3)) 

2.3 数组维度变更

---

t1 = np.array([[1, 2 ,3 ],[4 ,5 ,6]])
print(t1.ndim)    #维度 2
print(t1.shape)    #形状 (2,3)
print(t1.size)     # 数组元素总个数  
print(t1.dtype)   # t1 的元素类型

t1 = t1.reshape(2,3)  #修改数据形状  reshape  需要用变量进行接收
"""
arr.reshape(shape,order="C")
 - shape 数组重塑形状
 - order 数据重塑方向 （C : 行方向，F ： 列方向）
"""

# 多维转一维
t2 = t2.flatten()   # 多维数据转化为1维
t3 = t2.ravel()		# 分散化，多维转化为 1 维

# 转置

a = np.arange(20).reshape(4,5)

a = arr.transpose(arr , axes)
a = arr.T

# 换轴
arr.swapaxes(arr ,axis1,axis2)  # 换轴
arr.swapaxes（arr ,axis1,axis2）  # 对换数组的两个轴   输入数据、第一个轴整数、第二个轴整数

# 滚动制定轴
rollaxis（arr,axis,start）  # 向后滚动指定的轴

2.4 数组间的计算

---

# 广播机制

print(np.zeros(3))   # 全 0 数组
print(np.ones(4))    #全 1 数组

print(np.zeros((3,4)))   # 全 0 数组
print(np.ones((3,4)))    #全 1 数组


arr = np.arange(6).reshape(2,3)
arr + 1     # 全部元素 + 1
arr * 2     # 所有数字全部 *2
# nan 非数     inf（正无穷、负无穷）无穷大

#数组和数组的计算
arr + arr1   #  对应位置相加减
arr * arr1   #  对应位置相乘/相除

# 数组垂直拼接（行堆叠）
numpy.vstack(arr,arr1) 
# 数组水平拼接（列堆叠）
numpy.hstack(arr,arr1) 

2.5 数据读取切片

---

• loadtxt 参数读取CSV文件
  • frame : 读取文件名称
  • dtype ：数据类型（文件内容读取出来的格式）
  • delimiter ： 数据之间用什么符号进行分隔，默认空格
  • skiprows ： 跳过前X行，一般是表头
  • usecols ：读取指定的列，索引，元组类型
  • unpack ： 对角线行列转置 ，如果为True，读取属性将分别写入不同的数组变量，False读取数据只写入一个数组变量，默认为False

#读取CSV文件 

t1 = np.loadtxt(fname,dtype = np.float,delimiter = None，skiprows = 0,usecols = None,unpack = False)


print(t1[2])   # 取第二行数据
print(t1[：3])   # 取前三行数据
print(t1[:3:2])   # 取前三行，步长为2
print(t1[[0,2]])   # 取不连续的多行

print(t1[:,0])  #取列，逗号前代表全部的列，都行后边代表行，全部列的 第 0 行
print(t1[:,：2])  # 取前两列
print(t1[:,：[0,3]])   # 取不连续的列

print(t1[1:3,：2])   #不相邻的多列
print(t1[1:0,[1,3]])  # 取点  [1,1] + [0,3]

2.6 数组中值的修改

---

arr1 = np.arange(24).reshape(4,6)

# 将第二列的值全部修改为 0
arr1[:,2] = 0

#布尔索引
arr1 < 10    # 全部元素与 10 比较，返回 true或flase

# 通过布尔进行筛选数值
arr1[ arr1 < 10 ]    # 整体可以选择小于 10的数

# 三元转化
t = np.where(t<10,0,10)  # 不修改函数本身，如果小于10，则显示 0，如果大于 0，则显示10

t.clip(10,18) # 小于10 的替换成10，大于18的替换成18

#数组中nan的处理（nan 和 inf  都是 float类型）
#  nan ！= nan    nan和任何数值计算都是nan
np.count_nozero(t)   # 判断不为零的数的个数
np.count_nozero(t！= t)   # 用来判断nan的个数
np.isnan(t)   # 判断是否为nan,若为 nan 则返回 True

#numpy中的常用方法  axis  数组中的轴
t.sum(axis = None)  #求和
t.mean(a,axis = None)  #均值
np.median(t,axis = None) #中值
np.max(axis = None)  #最大值
np.min(axis = None)  #最小值
np.ptp(t,axis = None)  #极值（最大最小之差）
np.std(t,axis =None)  #标准差
np.var(arr)		# 方差

np.cumsum(arr)	# 从 0 位置开始累加


np.concatenate  #连接沿现有轴
np.stack()   # 沿着新的轴接入一系列数组

np.argmax(t,axis = 0)  # 获取最大值的位置-索引
np.argmin(t.axis = 1)  # 获取最小值的位置-索引

# 分隔数组
numpy.split(ary, indices_or_sections, axis)  # 沿特定的轴将数组分隔为自数组  ary：被分隔数组  indices_or_sections 如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭） axis 分隔的 轴 
np.hsplit(harr, 3)  # 水平分割数组 
numpy.vsplit（a ,2 ）  # 沿垂直轴分割

#数组元素的添加与删除
numpy.resize(arr, shape)  # 返回指定形状的新数组
numpy.append(arr, values, axis=None) # 将值添加到数组末尾  
numpy.insert(arr, obj, values, axis)  #在给定的索引之前，沿给定的轴在输入数组中插入值
Numpy.delete(arr, obj, axis)
numpy.unique(arr, return_index, return_inverse, return_counts)  #函数用于去除数组中的重复元素
#   return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
#   return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
#   return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

2.7 Numpy字符串函数

---

np.char.add(['hello', 'hi'],[' abc', ' xyz'])  #两数组逐个字符串元素进行连接
>> ['hello abc' 'hi xyz']

np.char.multiply('Runoob ',3)  # 返回按元素多重连接后的字符串
>> Runoob Runoob Runoob

np.char.center('Runoob', 20,fillchar = '*')  # 据中字符串
>> *******Runoob*******

np.char.capitalize('runoob')  # 将字符串的第一个字母转化为大写
>> Runoob

np.char.title('i like runoob')  #函数将字符串的每个单词的第一个字母转换为大写
>> I Like Runoob

np.char.lower(['RUNOOB','GOOGLE'])   #函数对数组的每个元素转换为小写。它对每个元素调用 str.lower
>> ['runoob' 'google']

np.char.upper(['runoob','google'])   #函数对数组的每个元素转换为大写。它对每个元素调用 str.upper
>> ['RUNOOB' 'GOOGLE']

np.char.split ('www.runoob.com', sep = '.')  #通过指定分隔符对字符串进行分割，并返回数组
>> ['www', 'runoob', 'com']

np.char.splitlines('i\nlike runoob?')  # 函数以换行符作为分隔符来分割字符串，并返回数组
>> ['i', 'like runoob?']

np.char.strip('ashok arunooba','a')   # 函数用于移除开头或结尾处的特定字符
>> shok arunoob

np.char.join([':','-'],['runoob','google'])   # 函数通过指定分隔符来连接数组中的元素或字符串
>> ['r:u:n:o:o:b' 'g-o-o-g-l-e']

np.char.replace ('i like runoob', 'oo', 'cc')  #函数使用新字符串替换字符串中的所有子字符串
>> i like runccb

2.8 numpy排序、条件刷选函数

---

# 数据处理

np.reciprocal(a)  # 返回数组a 的所有元素的 倒数
np.power(a,b)   # 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂
np.mod(a,b)  # 对应位置相除、取余数
np.amin(a,0)   # 获取数组中指定元素沿轴方向的最小值
np.amax(a,0)   # 获取数组中指定元素沿轴方向的最大值
np.ptp(a, axis =  1)   # 计算数组中元素最大值与最小值的差（最大值 - 最小值） 
numpy.percentile(a, q, axis)   # 百分位数是统计中使用的度量，表示小于这个值的观察值的百分比  数组、百分数、轴向
np.median(a, axis =  0)  #计算数组中的中位数
np.mean(a, axis =  0)  # 计算数组中的 算术平均值
np.average(a)  # 根据另一个数组给出的各自的权重计算数组中元素加权平均值


# 数组处理
numpy.sort(a, axis, kind, order)   # 排序数组、轴方向、排序方法（默认快排）、排序字段
np.argsort(x)  # 返回数组从小到大的数据的索引值
np.lexsort((dv,nm))   # 对多序列进行排序
msort(a) == np.sort(a, axis=0)  # 按照第一轴进行排序
sort_complex(a)   #对复数按照先实数、后虚部进行排序
partition(a, kth[, axis, kind, order])  #指定一个数、对数组 进行分区
argpartition(a, kth[, axis, kind, order])   # 可以通过 关键字 kind指定算法 沿着指定轴对数组进行分区

---

3、Pandas 库

---

3.1 Pandas 介绍

---

• 在numpy基础上进行升级而来的一个库，numpy主要用来处理数值型的数据
• 我们拿到的数据除了数值型，还有其他类型的数据，比如字符串、时间序列等，所以我们需要一个库来进行处理，所以引进了 pandas

3.2 Pandas数据类型

---

• Series ： 一种一维的数据对象，包含一个值序列，并包含数据标签，成为索引（index）
• DataFrame ：矩阵的数据表，包含多个 有序的列集合，每行可以是不同类型的数据，数据被存储为二维块

3.3 Series数据创建

---

# pip install pandas

# 数据组成 ： index、name、value
# data传入 ：列表、字典、向量

import pandas as pd

# pd.Series(data=None,index=None,dtype=None,name=None,copy=False)

t = pd.Series([1,2,3,4,5],index=list('abcde'))  # 传入列表，可以指定索引
t = pd.Series([1,2,3,4,5],index=list('abcde'),name = "T") #整体数据的名字

t.index.name = T1  #索引行的名字



dic = {'A': 'a', 'B': 'b', 'C': 'c'}

t1 = pd.Series(dic)  # 键值对应索引，值对应值
print(t1)

> A    a
> B    b
> C    c


t2 = pd.Series(np.random.rand(5))   #可以传入numpy类型的数据

print(t2)

dtype: object
0    0.337169
1    0.929789
2    0.255028
3    0.697560
4    0.567698
dtype: float64

t3 = t2.astype("float") #类型转化  转化成float类型

3.4 Series索引切片取值

---

t3.head(2)   # 查看t3的前几行数据，默认五行

dtype: float64
0    0.266993
1    0.330825
dtype: float64


t3.tail(2)  #查看t3后几行数据，默认五条

dtype: float64
3    0.177648
4    0.960813
dtype: float64

t3.reset_index() 	# 重置索引
t3.reset_index(drop=True)  # 重置索引，删除原索引

# 通过键值对\索引进行取值、也可以通过函数的方式
t1[age] = 18   #

t1.loc['age'] = 18  # 通过标签索引取值
t1.iloc[1] = 18   # 通过索引方式取值

t1[：2]  # 取前两行的数据
t1[[1,3]]  # 取不连续的多行   也可以把数字换成 键值 也可以

# 数据中的index是允许修改的，如果想修改需要重置，就是全部修改，就是在索引后面再加一样索引。

3.5 Series数据类型相加

---

• 对应的索引位相加、而没有对应上的之间显示NAN（索引相同才可以互相运算）

3.6 Pandas 数据读取

---

# index_col = 0 指定 0 列为索引
# parse_dates 将时间转化成标准格式
pd.read_csv（"data",index_col=0,parse_dates=True）  #读取外部csv数据
pd.to_csv('data')   # 把数据写入到CSV中

3.7 DataFrame数据创建

---

• DateFrame参数
  • 创建的数据 ：data
  • 指定行索引 ：index
  • 指定列索引 ：colums
  • 数组数据类型 ：dtype
  • 是否拷贝 ：copy

"""
pd.DataFrame(data = None,index = None,columns =None,dtype = None,copy = False)
"""
t = pd.DataFrame(np.arange(12),reshape(3,4))   # dataframe数据的创建
# index 行索引   0轴  axis = 0      columns 列索引  1轴  axis = 1
#通过字典类型创建  遵循广播机制，没有的就用有的补

#pandas 中的基础属性
df.shape  # 行数、列数
df.dtypes  # 列数据类型
df.ndim   #数据维度
df.index   #行索引
df.columns   # 列索引
df.values   # 对象值，二维ndarray数组
df.drop(columns = ['name','age'])    #返回被删除后的 dataframe原数据不变
del df['name']    # 删除列

3.8 DataFrame数据索引操作

---

t2.head(3)   #显示头部几行、默认5行
t2.tail(3)    #显示末尾几行，默认5行

t2.info()    # 数据描述信息概述   数据清洗的时候 通过此判断清洗情况
t2.describe()   #快速综合统计结果 
df.sort_values(by="",ascending = False)  # by 后面接根据什么来排序  True 升序   False 降序

df[:2]  #取前两行  方括号写数组，表示取行，对行进行操作
df[:"标签索引名"]  # 取 到标签索引名的行

df["列名称"]   # 取相应的列，对列进行操作。
df[["列名称1","列名称2"]]   # 取相应的多列，对列进行操作。
df[df["name" != "lcl"]]  # 取出名字不等于 lcl的行，条件筛选

df[:2]["列名"]   #同时取行和列，取确切位置
df.loc["python",:]  #通过标签索引取行数据，取 索引为 python 的行
df.loc[:,"three"]	# 取索引为 three 的列
df.loc[["php","go"],:]		# 取多行
df.loc[["php":"go"],:]		# 取多行，从 php 行到 go 行

df.iloc[2,:]   # 通过位置获取行数据, 取出第二行的全部数据
df.iloc[:,2]	# 取出第三列
df.iloc[[0,2],:]	# 取出第 0 行 和第 2 行数据

b.swaplevel()  # 交换索引的位置，应用于符合索引

#pandas 字符串常用方法
df.str.contains()   # 返回表示个字符串是否含由指定模式的布尔型数组
df.str.len()	# 返回字符串的长度
df.str.lower()	# 转化为小写
df.str.upper()  # 转化大写
df.str.slice()   # 对series中的各个字符串进行子串截取
df.str.split()  # 根据分隔符或正则表达式对字符串进行拆分

3.9 DataFrame 算数

---

方法	描述
add	加法（+）
sub	减法（-）
div	除法（/）
floordiv	整除（//）
mul	乘法（*）
pow	幂次方（**）

# fill_value 的值对 df1 缺失位置填充 3，然后再计算
df1.add(df2,fill_value = 3)		# df1 + df2



# 索引排序 （axis 轴，ascending 排序方式，True 为升序 ）
df.sort_index(axis=0,ascending = True)	

# 按值排序 (by 指定一列或多列作为排序键)
df.sort_values(by=0)	# 指定第一列进行排序
df.sort_values(by=[0,1])	# 多列进行排序
df.sort_values(axis=1,by="b")	# 指定轴的排序

常用计算方法

方法	描述
count	非NA值个数
min,max	最大、最小值
argmin，argmax	最大、最小值的索引位置
idxmin,idxmax	最大、最小值的标签索引
sum	求和
mean	平均值
median	中位数
var	方差
std	标准差
cumsum	累计值
pct_change	百分比

# 多维度统计
data.aggregate([np.mean,np.std,np.median,min,max])

# 每项指标的差异值，后一天的值减去前一天的值
data.diff()

# 计算增长率（后一天的值 - 前一天的值）/前一天的值
data.pct_change()

3.10 DataFrame数据处理

---

3.10.1、缺失数据处理

---

# 判断数据是否有NaN (内置的None 默认为 Nan)
pd.isnull(df)	# 返回哪些值是缺失得布尔值
pd.notnull(df)	# 返回值是 isnull 的反集

# 过滤缺失值
"""
how —— 只要有Nan 就删除行
all —— 一行全部为Nan 时才删除
inplace —— 修改被调用的对象，而不是一个备份
"""
data.dropna( axis = 0,how = 'any/all' , inplace = False )  # 可以指定轴

3.10.2、补全缺失值

---

data.fillna(value= None,method = None,axis =None,inplace =Flase,limit =None)
"""
value : 标量或字典对象用于填充空缺值
method : 插值方法，默认 ffill（向上插补）
axis : 需要填充的轴，默认为 0
inplace : 修改被调用的对象，而不是一个备份
limit ： 用于向前或向后填充时，最大的填充范围
"""
t.fillna(2)   # 将 Nan替补为 2
t.fillna({"x":3.0,"y":4.0})		#  X 列的 Nan 替换为3，Y 列替换为 4
t.fillna(df.mean())		# 填充均值
t.fillna(method="ffill")	# 往上插补（用上一行的数据来填充下一行的 Nan）

3.10.3、异常值

---

"""
to_replace 去替换的值
value 替换的值
"""
df.replace(to_replace=None,value =None)

3.10.4、处理重复数据

---

# 判断重复值
"""
subset : 指定子  列  判断重复
keep : 默认为 first 保留首个出现的 last 保留最后出现
"""
df.duplicated(subset =None,keep = "first")  # 返回一个布尔值 Series,默认反映的是每一行是否与之前出现的行相同


# 删除重复值 (返回 DataFrame 默认删除)
"""
subset : 指定数据任何自己是否重复
keep : 默认为 first 保留首个出现的 last 保留最后出现
"""
df.drop_duplicates()
df.unique()  # 返回一个列表

3.10.5、数据打印不全处理

---

pd.set_option('display.max_rows',1000)
pd.set_option('display.max_columns',1000)

3.10.6、字符串的离散化

---

• 将连续值进行分区间
• 同一个数据属于多种属性

# 对数据进行离散化分组
# data 数据、bins 分组范围、bins
pd.cut(data,bins)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

age_arr = np.random.randint(20,60,size=20)
bins = [20,30,40,50,60]
cates = pd.cut(age_arr,bins)
print(data)
cates.codes  # 返回数据分布 所在的组的索引
cates.categories # 返回表示 右闭合区间

# 自定义区间标签
l_name = ["youth","youngAdult","MiddleAged","Old"]
cates = pd.cut(age_arr,bins,labels = l_name)

# 统计每个区间的数值分布
pd.value_counts(cates)

3.10.7、索引与分层索引

---

df.index	# 查看索引
df.index=[,]	# 指定索引
df.reindex([,])		# 重置索引
df.set_index("M",drop=Flase)	# 设置M列作为index
df.set_index("M").index.unique()	# 返回 index 的唯一值


import pandas as pd
import numpy as np

df = pd.DataFrame(np.arage(12).reshape(3,4),index = list("ABC"),columns = list("QWER"))

df.index  # ['A','B','C']
df.index[1]  # B
df.index = ['B','C','D']    # 将索引全部修改

# 重置索引，如果原数据没有，则自动补齐 Nan
df.reindex(['F','G','G'])		# 重置索引

# 指定某列作为索引
df.set_index("M",drop=Flase)	
df.set_index(["M","D"])		# 指定多行索引

# 查看索引重复
df1.index.unique()

# 查看索引是否存在重复值
data.index.is_unique

df1.loc["one"]		# 取所有索引为 one
df1.loc["one","two"]	
df1.loc[["one","two"]]	

df1.loc["one","j"]	
df1.loc["one"].loc["j"]	

3.11 Pandas 中的时间序列

---

• 在多个时间点观测地数据形成地时间序列
• 时间戳
• 固定时间区域
• 时间间隔

# Periods 时间范围的个数，freq 频率，以天为单位还可以以月为单位,normalize 是否保留后面的时分秒
pd.date_range(start = None,end = None ,periods = None, freq = 'D',normalize=flase) 
D --Day   #  每日
B -- BusinessDay  # 工作日
H -- Hour  # 每小时
T / min  -- Minute # 每分
S -- Second  # 每秒
L/ms  -- Million # 每毫秒
U -- Micro # 每微妙
M -- MonthEnd  # 每月最后一个日期

index = pd.date_range("20190101",periods = 10)
df = pd.DataFrame(np.arange(10),index = index )   # 作为行索引
df = pd.DataFrame(np.arrge(10),reshape(1,10),columns = index)  # 作为列索引

# 获取 2020年数据
data["2020"]
# 获取 2020年 5月
data["2020 05"]  /  data["2020/05"] /  data["2020-05"]

# 重复索引分组 再聚合
group_data = data.groupby(level=0)
group_data.sum()
group_data.mean()


# 移位日期（是对数值进行移位） —— 讲日期按时间向前移动或向后移动 
# 一般用于计算增长率
data.shift(2)  # 向前移动
data.shift(-2) # 向后移动


# 数值不变，对时间序列进行移位
data.shift(2,freq ="D")

3.11.1、pandas 重采样

---

• resample
• 重采样：将时间序列从一个频率转化为另一个频率进行处理的过程
• 降采样：将高频率数据转化为低频率数据
• 升采样：低频率转化为高频率

# resample 中传入的是频率
print(t.resample("M").mean())   # 例如时间序列，把本月的数据取平均值，最后显示只显示月度数据

# 低频转化高频
data.resample("D").asfreq()
data.resample("D").ffill()

3.11.2、虚拟化变量

---

• 类似 jiba 分词

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame({
	"key":['b','b','a','c','a','b'],
	"data":range(6)
})

# 实现数据的虚拟化 pd.get_dummies（）
data = pd.get_dummies(df["key"],prefix="key")


**#虚拟化例子**

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv("IMDB-Movie-Data.csv")
all_genres = []
for x in df["Genre"]:
    li = x.split(",")
    all_genres.extend(li)
#print(all_genres)

genres = pd.unique(all_genres)
zero_data = np.zeros((len(df),len(genres)))

# 构建数组
zero_data = pd.DataFrame(zero_data,columns=genres)

"""
# 获取当前行数据的位置
f_data = f_data.split(",")
zero_data.columns.get_indexer()
"""
# 获取df.Genre 中 每一个 元素以及对应的索引
for i,genre in enumerate(df.Genre):
	# 获取列索引所在位置
	col_index = zero_data.columns.get_indexer(genre.split(","))
	zero_data.iloc[i,col_index] = 1

3.11.3、数据的合并

---

#数据合并
join  # 默认情况下，把行索引相同的数据合并到一起，列不能有重复

df1 = pd.DataFrame(np.arange(12).reshape(3,4),index=list("ABC"),columns=list("DEFG"))
df2 = pd.DataFrame(np.arange(6).reshape(2,3),index=list("AB"),columns=list("WXY"))
print(df1.join(df2))
print(df2.join(df1))


# 数据堆叠   pd.concat()
data = pd.concat([arr1,arr2,arr3],axis=0)


merge # 按照指定的列把数据按照一定的方式合并到一起，以列为基准，需要有公共的列（类似于vlookup）

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

df1 = pd.DataFrame(np.arange(6).reshape(2,3),index=list("AB"),columns=list("XYZ"))
df2 = pd.DataFrame(np.arange(6).reshape(3,2),index=list("ABC"),columns=list("WZ"))
print(pd.merge(df1,df2))

# 执行拼接方式,on 指定拼接列（须为公共列）
# 类似于 vlookup
pd.merge(df3,df4,how="left",on="")

how # 指定拼接方式 inner、outer、left 、right 默认为 inner
on # 需要连接的列名 （须为公共列）
left_on # 左边数据中用作连接的列
right_on # 右边数组中用做连接的列

3.11.4、数据的分组

---

# 数据的分组
import pandas as pd
import numpy as np

data = {
    "key1":['a','a','b','b','a'],
    "key2":['one',"two","one","two","one"],
    "data1":np.arange(5),
    "data2":np.arange(5)
}

df = pd.DataFrame(data)
data_one=df.groupby('key2').sum()
print(data_one)


df,groupby(by = "columns_name")   # 根据列名进行分组
count # 分组中非NAN值得数量
sum  # 非 Na值得和
mean  #非Na 值得平均值
min/max  # 非Na值得最小值、最大值

# 索引和符合索引
t.index   # 简单索引
t.index ['a','b','c']  # 指定index
t.reindex['a','e']  # 重设index
t.set_index("M",drop = False)  # 指定某一列作为index
t.set_index("M").index.unique()   # 返回index的唯一值

#  Series 符合索引
a = pd.DataFrame({'a':range(7),'b':range(7,0,-1),'c':['one','one','one','two','two','two','two'],'d':list("hjklmno")})   # 设置c,d 为索引，设置 d,c为索引

4、Matplotlib库

---

• 流行的python底层绘图库，制作 2D 可视化图表
• 官网 ： http://c.biancheng.net/matplotlib/

4.1 绘制过程

---

• 设置图片大小
• 保存到本地
• 描述信息，X 和 Y轴表示
• 调整X,或 Y 的刻度距离
• 线条样式（颜色、透明度）
• 标记特殊点（最高、最低）
• 给图片加水印（防伪用）

# https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.plot.html#matplotlib.axes.Axes.plot


# 假设一天中每隔2小时的温度分别为  [15,13,14.5,17,20,25,26,26,27,22,18,15]

from matplotlib import pyplot as plt

# 设置图片大小（宽、高）、 dpi图片的清晰度（最大值100）
fig = plt.figure(figsize =(20,8),dpi = 80)

x = range(2,25,2)
y = [15,13,14.5,17,20,25,26,26,27,22,18,15]

plt.xlabel('time')   #设置X轴描述信息 直接显示在图表中
plt.ylabel('temp')   #设置Y轴描述信息 直接显示在图标中

plt.title("图像title")  # 设置图像title

plt.plot(x,y，label ="图例显示内容"，color = "red",marker = "o",linestyle = "dashed",linewidth =2,marksize = 12)

_x = range(2,25,2) 

# 列表推倒式 含义同_x = range(2,25,2)  ，_x = [i/2 for i in range(4,50)]

plt.xticks(_x, _xtick_lable)   # 设置X轴的刻度,如果_xtick_lable不为空，则会在显示时替换到_X
plt.yticks(_y)   # 设置Y轴的刻度

plt.grid()   # 绘制网格线（可根据效果省略）
plt.legend(prop = front)   # 绘制图例（跟绘图中的label标签配合使用） 参数中是显示中文图例参数
plt.savefig('./matp.png')  # 将图片保存到本地

plt.show()  #展示画好的图

5、Seaborn库

---

5.1 Seaborn介绍

---

• 基于 matplotlib 组数据结构与 pandas 统一的统计图制作库。封装了一系列的方便绘图函数

5.2 Seaborn 安装

---

# pip 安装
pip install seaborn

#anaconda 安装
conda install seaborn

学习文档

• 官网 ：http://seaborn.pydata.org/
• 中文文档 ：https:www.cntofu.com/book/172/docs/1.md

5.3 Seaborn绘图模块

---

• 关系型绘图
• 分类型绘图
• 分布型绘图
• 线性关系绘图

5.3.1 关系型绘图

---

• 表示多个变量之间的关联关系，默认情况绘制散点图，也可以绘制线性图，通过 kind参数进行指定
• 关系图绘制 ： seaborn.relplot()
• 散点类型 ：scatterplot : relplot(kind = “scatter”)
• 线性类型 lineplot : relplot(kind = “line”)

import seaborn as sns
import pandas as pd
from matplot import pyplot as plt
import numpy as np 

# sns.load_dataset()加载在线数据集
tips = sns.load_dataset("tips",cache = True)    # cache 保存
# 读取本地数据集
tips = pd.read_csv("/seaborn-data-master/tips.csv")

# 绘图、默认散点图
sns.relplot(x="total_bill",y ="tip",data=tips)
# 绘制散点图
sns.scatterplot(x="total_bill",y ="tip",data=tips)

# hue 参数控制第三个变量的颜色显示（每个点属于星期几，用不同颜色标出）
sns.relplot(x="total_bill",y ="tip",hue = "day",data=tips)

# 根据某个属性值，对每个属性值进行绘制子图 （lunch、dinner）
# 通过 col 、 row 进行指定
sns.relplot(x="total_bill",y="tip",hue ="day",col ="time",data=tips )
# 性别 + 时间分组（4个子图）
sns.relplot(x="total_bill",y="tip",hue ="day",col ="time",row = "sex",data=tips )

# 绘制折线图
fmri = sns.load_dataset("fmri")
# ci 设置置信区间（置信区间）
sns.relplot(x="timepoint",y="signal",kind ="line",data=fmri，ci = None,hue ="region",col ="event",style="region")
# 绘制折线图
sns.lineplot(x="timepoint",y="signal",data=fmri)

5.3.2 分类型绘图

---

• 通过 sns.catplot 来实现，默认绘制的是 分类散点图，也可以通过 kind 来进行指定
• 分类散点图、分类分布图、分布统计图
• sns.catplot()

# 分类散点图
sns.catplot(x ="day",y ="total_bill",data = tips , hue ="sex")

# 分布散点图（kind ="swarm" 点之间不重叠）
sns.catplot(x ="day",y ="total_bill",data = tips , hue ="sex",kind ="swarm")

5.3.3 分类分布图

---

• 根据分类，每个分类下数据的分布情况，通过catplot 来实现
• 箱型图（ boxplot() (with kind=“box”)）
• 小提琴图 （violinplot() (with kind=“violin”)）

# 箱型图
sns.boxplot(x ="day",y ="total_bill",data = tips , hue ="sex",kind ="box")

# 小提琴图
# inner = "quartile"  指定 四分位
sns.violinplot(x ="day",y ="total_bill",data = tips,inner ="quartile",hue ="sex",split=True)

5.3.4 分类统计图

---

• 根据分类、统计每个分类下的数据的个数或比例
• 条形图 ：sns.barplot() —— （with kind =“bar”）
• 柱形图 ：sns.countplot() —— （with kind =“count”）
• 点线图 ： sns.pointplot() —— （with kind =“point”）

# 条形图 : 可以统计比例，平均数，也可以按照想要的统计函数来统计
# estimator 指定 求和 总数
sns.catplot(x ="day",y ="total_bill",data = tips ,kind ="bar",estimator=sum)

# 柱形图 ： 统计某一变量出现数量的图形
sns.catplot(x ="sex",data = titanic,kind ="count")

# 点线图	: 变量之间的变化趋势
sns.catplot(x="sex",y="survived",data=titanic,kind="point",hue="class")

5.3.5 分布绘图

---

• 主要分为单变量分布以及而变量分布 和 pairplot
• 单变量分布 ：主要 通过直方图来绘制，采用 distplot
• 二变量分布 ：观察两个变量之间分布的关系，一般采用多个图进行，函数为 jointplot

# 单变量分布
titanic = pd.read_csv("./seaborn-data-master/titanic.csv"))
titanic.head()
sns.distplot(titanic["age"])


# 二变量分布
tips = sns.load_dataset("tips")
g = sns.jointplot( x = "total_bill",y  ="tip",data = tips)

# 通过设置 kind ='reg' 可以设置回归绘图和核密度曲线
# 通过设置 kind = 'hex' 可以绘制六边形图

"""
jointplot 其他常用参数
1、x,y,data : 绘制图的数据
2、kind ： scatter 、reg 、resid 、kde 、hex
3、color : 绘制元素颜色
4、height : 图的大小、图绘在一个正方形
5、ratio : 主图 和副图的比例，只能为一个整数
6、space : 主图和副图的间距 
7、dropna : 是否需要删除 x 或 Y值 中出现的 Nan的值
8、marginal_kws : 副图的一些属性，比如设置 bins、rug 等
"""


# **pairplot**
# 默认情况下，对角线的图 是直方图，其他地方是散点图，如果想更改可以通过 diag_kind 和 kind 来实现
# diag_kind : auto,hist,kde  (指定对角线曲线类型)
# kind : scatter ,reg（回归线）
sns.pairplot(tips,var=["total_bill","tip"],kind="reg")

5.3.6 线性回归绘图

---

• 线性回归图 帮助看到数据的关系趋势，在 seaborn 中，通过 regplot 和 lmplot 两个函数来实现
• regplot 的 X,Y 可以是 Numpy 数组，Series等变量 —— regplot(x,y,data=None)
• lmplot 的 X,Y 则必须为字符串，并且 data的值不能为空 —— lmplot(x,y,data)

# 散点图 + 回归线
sns.regplot(x="total_bill",y="tip",data=tips)
sns.lmplot(x="total_bill",y = "tip",data = tips)

5.3.7 FacetGrid结构图

---

• 官网地址 ：https://seaborn.pydata.org/tutorial/color_palettes.html
• relplot、catplot、lmplot 等函数都可以通过 col、row 等在一个 Figure 中绘制多个图
• 这些函数之所有有这些功能，主要是底层使用了 FacetGrid 来组装这些图形

Axes绘图

• seaborn 绘图中很多底层使用 Axes 进行绘图
• 凡是函数名中已经明确了绘图类型函数，这种图一般使用Axes.
• 使用Axes 绘图的 不能传入 col、row 等参数绘图

import seaborn as sns
import pandas as pd
from matplot import pyplot as plt
import numpy as np

# plt.subplots（）  有两个返回值

fig , ax = plt.subplots(1,2,figsize(20,5))
sns.scatterplot(x="total_bill",y = "tip",data = tips ,ax = ax[0])
sns.scatterplot(x="total_bill",y = "tip",data = tips ,ax = ax[1])

FaceGrid使用步骤

• 创建一个FaceGrid对象
• 再调用这个对象的map方法
• map 的第一个参数是函数
• 后续 map 通过调用该函数绘制图形
• 最后的参数是传给函数的 参数

tips = sns.load_dataset("tips")

# 绘制散点图 —— （day 数据进行分组）
# height=4,aspect=2 设置绘图图形的宽高,比例
g = sns.FacetGrid(tips,col = "day",hue = "time",height=4,aspect=2)
# order 指定图形数据顺序
g.map(plt.scatter,"total_bill","tip",order=["Sat","Fri","Sun",....])

设置图例

# 设置显示中文
sns.set(rc={"font.sans-serif":"SimHei"})

fg2 = sns.FaceGrid(tips.col="day",hue="time")
fg2.map(sns.regplot,"total_bill","tip")

# 添加图例(方法1)
fg2.add_legend(title="标题",labels=["晚餐","午餐"],label_order=["Dinner","Lunch"])

# 添加图例（方法2）
fg2.add_legend(title="标题",label_order=["Dinner","Lunch"])
new_labels=["晚餐","午餐"]
for text,label in zip(fg2._legend.texts,new_labels):
	text.set_text(label)

设置标题

• 设置函数 ：g.set_titles(template=None,row_template=None,col_template=None)
• template : 给图设置标题 {row_var} : 绘制每行图形的名称 ，{row_name} : 绘制每行图形的值，{col_var} : 绘制每列图像的名称 ，{col_name} : 绘制每列图像的值
• col_template : 给图像设置的标题。其中 {col_var} 、{col_name} 可以使用
• row_template : 给 图像 设置行的 标题。其中 {row_var} 、{row_name} 可以使用

g = sns.FacetGrid(tips.col="day",row="time")
g.map(sns.regplot,"total_bill","tip")
g.set_titles(template="时间{row_name}/星期{col_name}")

设置坐标轴

• 设置坐标轴 ：g.set_axis_labels(x_var,y_var) : 一次性设置 X,Y 的坐标轴标题

# 设置坐标轴标签
g.set_axis_labels("消费金额","消费") 
# 设置刻度及刻度标签
g.set(xticks= range(0,60,10),xticklabels=["0rmb","10rmb","20rmb","30rmb","40rmb","50rmb",])
# 设置背景颜色(绿色)
g.set(facecolor ="g")

风格设置函数

• sns.set_style()
• sns.axes_style()
• sns.set()

tips =pd.read_csv("data.csv")
fmri = pd.read_csv("data1.csv")


# set_style 设置风格
sns.set_style("darkgrid")


# rc 中传入样式设置 - 临时设置
with sns.axes_style("darkgrid",rc={'axes.facecolor':'white'})：
	sns.lineplot(x="timepoint",y="signal",data=fmri)


# sns.set() 设置风格
sns.set(rc={'axes.facecolor':'white'})

调色盘设置

• 根据应用场景提供三种调色盘
• 定性的、连续的、发散的

# 定性调色盘 —— 数据不连续、较发散、想体现分类的情况下使用
planets = pd.read_csv("data.csv")

# palette 设置调色盘参数
# hls 调色盘- 默认6种颜色
sns.barplot(x="year",y="distance",data=planets,palette = sns.color_palette("hls"))


# 默认调色盘 (默认10种)
# 通过 sns.color_palette 获取
current_palette = sns.color_palette()
sns.palplot(current_palette)


# 分类颜色
sns.palplot(sns.color_palette("Paired"))
sns.palplot(sns.choose_colorbrewer_palette("qualitative"))

# 连续调色盘
# 由浅入深
sns.palplot(sns.color_palette("Blues"))
# 由深入浅
sns.palplot(sns.color_palette("Blues_r"))


# 离散调色盘(两边的颜色逐渐加深，中间最淡)

values = [12,15,17,18,-5,-8]
# 查看色调选择
sns.choose_colorbrewer_palette("diverging")
with sns.color_palette("RdBu_r")
	sns.barplot([1,2,3,4,5,6],sorted(values))

6、Pyeharts库

---

6.1 Pyecharts介绍

---

• 是百度开发的一个绘图库、不支持复杂df的数据类型
• 官网地址 ：https://pyecharts.org/#/zh-cn/global_options?id=legendopts%ef%bc%9a%e5%9b%be%e4%be%8b%e9%85%8d%e7%bd%ae%e9%a1%b9

6.2 Pyecharts绘图

---

6.2.1 绘制条形图

---

# -*- coding: UTF-8 -*-

from pyecharts.charts import Bar

# 方法实例化
bar = Bar() 
bar.add_xaxis(["衬衫","羊毛衫","雪纺衫","裤子","高跟鞋","袜子"])
bar.add_yaxis("商家A",[5,20,36,75,90，60])
bar.render()

链式调用

from  pyecharts.charts import Bar

bar = (
	Bar()
	.add_xaxis(["衬衫", "羊毛衫", "雪纺衫", "裤子", "高跟鞋", "袜子"])
	.add_yaxis("商家A", [5, 20, 36, 10, 75, 90])	
)
bar.render()

6.2.2 配置项

---

• 标题配置项 — TitleOpts
• 图例配置项 — LegendOpts
• 工具箱配置项 — ToolboxOpts
• 提示框配置项 — TooltipOpts
• 视觉映射配置项 — VisualMapOpts (0-100)
• 区域缩放配置项 — DataZoomOpts

6.2.2.1 InitOpts：初始化配置项

---

• 可以配置诸如图像宽度，高度，图表主题，背景颜色等

from pyecharts.charts import Bar
from pyecharts import options as opts
from pyecharts.globals import ThemeType
from faker import Faker

c = (
        Bar(
        	# 初始化配置
            init_opts=opts.InitOpts(
            	# 图像宽度
                width="500px",
                # 图像高度
                height="400px",
                # 图像主题
                theme=ThemeType.LIGHT,
                # 图像背景色
                bg_color="skyblue"
            )
        )
        .add_xaxis(Faker.choose())
        .add_yaxis("商家A", Faker.values())
        .add_yaxis("商家B", Faker.values())
    )
c.render()

6.2.2.2 TitleOpts：标题配置项

---

• 配置图的标题和子标题等信息

c = (
        Bar()
        .add_xaxis(Faker.choose())
        .add_yaxis("商家A", Faker.values())
        .add_yaxis("商家B", Faker.values())
        # 全局化配置
        .set_global_opts(title_opts=opts.TitleOpts(
        	# 主标题
            title="销售表",
            # 副标题
            subtitle ="水果商户"
            pos_right="0",
            pos_bottom="2px",
            # 主标题样式配置项
            title_textstyle_opts=opts.TextStyleOpts(**{"color":"#333","font_size":12})
        ))
    )
c.render()

6.2.2.3 LegendOpts：图例配置项

---

• 配置图的标题和子标题等信息

c = (
        Bar()
        .add_xaxis(Faker.choose())
        .add_yaxis("商家A", Faker.values())
        .add_yaxis("商家B", Faker.values())
        .set_global_opts(
            legend_opts=opts.LegendOpts(selected_mode="mutiple",orient="vertical",pos_right="30px")
        )
    )
c.render()

6.2.2.4 VisualMapOpts：视觉映射配置项

---

c = (
    Scatter()
    .add_xaxis(Faker.choose())
    .add_yaxis("商品",[(x,y) for x,y in zip(Faker.values(),Faker.values())])
    .set_global_opts(
        visualmap_opts = opts.VisualMapOpts(type_="size",range_text=['大','小'])
    )
)
c.render()

6.2.2.5 TooltipOpts：提示框配置项

---

c = (
    Scatter()
    .add_xaxis(Faker.choose())
    .add_yaxis("商家A",Faker.values())
    .set_global_opts(
        title_opts=opts.TitleOpts(title="Scatter-多维度数据"),
        tooltip_opts=opts.TooltipOpts(
        	# {a} 系列名、{b} 数据名、{c} 数据值
            formatter="{a}"
            )
        )
    )
)
c.render()

6.2.2.6 坐标轴轴线/刻度/指示器/坐标轴配置项

---

• xisLineOpts/AxisTickOpts/AxisPointerOpts/AxisOpts : 坐标轴轴线/刻度/指示器/坐标轴配置项

c = (
        Bar()
        .add_xaxis(
            [
                "名字拉拉长的X轴标签1",
                "名字拉拉长的X轴标签2",
                "名字拉拉长的X轴标签3",
                "名字拉拉长的X轴标签4",
                "名字拉拉长的X轴标签5",
                "名字拉拉长的X轴标签6",
            ]
        )
        .add_yaxis("商家A", [10, 20, 30, 40, 50, 40])
        .add_yaxis("商家B", [20, 10, 40, 30, 40, 50])
        .set_global_opts(
            xaxis_opts=opts.AxisOpts(
                name="商家名称",
                # 刻度标签旋转 15 度
                axislabel_opts=opts.LabelOpts(rotate=-15),
                # x轴 箭头的样式
                axisline_opts = opts.AxisLineOpts(symbol="arrow",linestyle_opts=opts.LineStyleOpts(width=2)),
                # y轴竖向的分隔线
                axistick_opts = opts.AxisTickOpts(is_inside=True,length=20),
                # 动态的分隔线
                axispointer_opts = opts.AxisPointerOpts(is_show=True,type_="line")
            )
        )
    )
c.render_notebook()

6.2.3 横向条形图

---

c = (

    Bar()
    .add_xaxis(Faker.choose())
    .add_yaxis("商家A", Faker.values())
    .add_yaxis("商家B", Faker.values())
    # 翻转 X,Y轴，绘制横向条形图
    .reversal_axis()
    .set_series_opts(label_opts=opts.LabelOpts(position="right"))
    .set_global_opts(title_opts=opts.TitleOpts(title="Bar-翻转 XY 轴"))
)
c.render()

6.2.4 堆叠图

---

c = (
    Bar()
    .add_xaxis(Faker.choose())
    # stack 参数设置堆叠
    .add_yaxis("商家A", Faker.values(), stack=True)
    .add_yaxis("商家B", Faker.values(), stack=True)
    .set_series_opts(label_opts=opts.LabelOpts(is_show=False))
    .set_global_opts(title_opts=opts.TitleOpts(title="Bar-堆叠数据（全部）"))
)
c.render()

6.2.4.1 设置条形图的间距

---

• category_gap参数：x轴每个分类的间距
• gap参数：统一分类下多根柱子间的间距

# y 值只有一个的情况
c = (

    Bar()
    .add_xaxis(Faker.choose())
    # 设置每个分类间距 category_gap
    .add_yaxis("商家A", Faker.values(), category_gap="80%")
    .set_global_opts(title_opts=opts.TitleOpts(title="Bar-单系列柱间距离"))
)
c.render()



# 有两个y轴数据的情况
c = (

    Bar()
    .add_xaxis(Faker.choose())
    # 设置多跟柱子的间距gap
    .add_yaxis("商家A", Faker.values(), gap="0%")
    .add_yaxis("商家B", Faker.values(), gap="0%")
    .set_global_opts(
        title_opts=opts.TitleOpts(title="Bar-不同系列柱间距离"),
    )
)
c.render()

6.2.5 带有网格的条形图

---

• 网格图，是在x轴和y轴上，都绘制横线，形成的网格。可以在opts.AxisOpts中通过设置splitline_opts实现

c = (
        Bar()
        .add_xaxis(Faker.choose())
        .add_yaxis("商家A", Faker.values())
        .set_global_opts(
            title_opts=opts.TitleOpts(title="Scatter-显示分割线"),
            # 设置网格线
            xaxis_opts=opts.AxisOpts(splitline_opts=opts.SplitLineOpts(is_show=True)),
            yaxis_opts=opts.AxisOpts(splitline_opts=opts.SplitLineOpts(is_show=True)),
        )
    )
c.render()

6.2.6 箱型图

---

v1 = [
    [850, 740, 900, 1070, 930, 850, 950, 980, 980, 880, 1000, 980],
    [960, 940, 960, 940, 880, 800, 850, 880, 900, 840, 830, 790],
]
v2 = [
    [890, 810, 810, 820, 800, 770, 760, 740, 750, 760, 910, 920],
    [890, 840, 780, 810, 760, 810, 790, 810, 820, 850, 870, 870],
]

c = Boxplot()
c.add_xaxis(["商品1","商品2"])
c.add_yaxis("A",c.prepare_data(v1))
c.add_yaxis("B",c.prepare_data(v2))
c.render()

6.2.6.1 绘图样例

---

c_athletes = athletes[athletes["NOC"].isin(list(countries.keys()))]

male_ath =[]
female_ath =[]

for country in countries.keys():
	# 城市匹配、性别为 M, 取身高列，删除 nan值
	male_h = c_athletes(c_athletes["NOC"]==country) & (c_athletes["Sex"]=="M")["Height"].dropna()
	# 城市匹配、性别为 F, 取身高列，删除 nan值
	female_h = c_athletes(c_athletes["NOC"]==country) & (c_athletes["Sex"]=="F")["Height"].dropna()
	male_ath.append(male_h)
	female_ath.append(female_h)

c = Boxplot(
	init_opts = opts.InitOpts(
		width = "800px",
		height = "400px",
		)
)
c.add_xaxis(list(countries.values()))
c.add_yaxis("男性",c.prepare_data(male_ath))
c.add_yaxis("女性",c.prepare_data(female_ath))
c.set_global_opts(
	yaxis_opts = opts.AxisOpts(interval =20,min _=120,max_ =240)
	)
c.render()

6.2.7 散点图

---

• 散点图用的是pyecharts.charts.Scatter来实现的

c = (
    Scatter()
    .add_xaxis(Faker.choose())
    .add_yaxis("商家A", Faker.values())
    .set_global_opts(title_opts=opts.TitleOpts(title="Scatter-基本示例"))
)

c.render()

6.2.8 多维散点图

---

c = (
    Scatter()
    .add_xaxis(Faker.choose())
    .add_yaxis(
        "商家A",
        [list(z) for z in zip(Faker.values(), Faker.choose())],
        label_opts=opts.LabelOpts(
            formatter=JsCode(
                "function(params){return params.value[1] +' : '+ params.value[2];}"
            )
        ),
    )
    .set_global_opts(
        title_opts=opts.TitleOpts(title="Scatter-多维度数据"),
        tooltip_opts=opts.TooltipOpts(
            formatter=JsCode(
                "function (params) {return params.name + ' : ' + params.value[2];}"
            )
        ),
        visualmap_opts=opts.VisualMapOpts(
            type_="color", max_=150, min_=20, dimension=1
        ),
    )
)
c.renderk()

6.2.9 中国地图

---

from pyecharts.charts import Map
c = (
    Map()
    .add("淘宝618", [list(z) for z in zip(Faker.provinces, Faker.values())], "china")
    .set_global_opts(
        title_opts=opts.TitleOpts(title="Map-VisualMap（连续型）"),
        visualmap_opts=opts.VisualMapOpts(max_=200),
    )
)

c.render()

6.2.9.1 中国局部地图

c = (
    Map()
    .add("商家A", [list(z) for z in zip(Faker.guangdong_city, Faker.values())], "广东")
    .set_global_opts(
        title_opts=opts.TitleOpts(title="Map-广东地图"),
        visualmap_opts=opts.VisualMapOpts(),
    )
)

c.render()

6.2.9.2 世界地图

---

c = (
    Map()
    .add("商家A", [list(z) for z in zip(Faker.country, Faker.values())], "world")
    .set_series_opts(label_opts=opts.LabelOpts(is_show=False))
    .set_global_opts(
    	# 标签设置
    	label_opts = opts.LabelOpts(is_show=False)
        title_opts=opts.TitleOpts(title="Map-世界地图"),
        visualmap_opts=opts.VisualMapOpts(max_=200),
    )
)

c.render()