python数据可视化之美——基础

编程基础

数据越来越多，人脑就那么大，我们要处理好数据，把数据转成图标比直接看数据更容易理解、有助于人做决策。

集合（set）：由唯一元素组成的无序集，{}或set()创建。

dc={key1:value1,key2:value2} =dict(key1=value1,key2=value2)

推导式（comprehensions):
[ 执行语句 for value in 集合 ] #使用执行语句生成列表
[ 执行语句 for value in 集合 if 条件 ] #根据一定条件生产列表

lambda：匿名函数

1. 仅由单条语句组成，执行的结果就是返回值，省略了def定义的步骤，没有名称属性
2. 可以接收任何数量的参数，但只能返回一个表达式的数值
3. lambda[ [参数1[,参数2，…, 参数n ] ] ：表达式

square =lambda x：x*x
print（square(2)） #结果为4

内置函数filter()

1. filter(布尔函数，序列)：
   调用布尔函数遍历序列中的每个元素，返回一个能够让布尔函数数值为True的元素序列
2. filter(lambda x:x>2,range(1,5)) #结果[3,4]

内置函数map()

1. map(func 函数，序列1 [, 序列2 ,…, 序列n ] )
   指定函数作用于给定序列的每个元素，用一个列表返回
2. map(lambda x:x*x,range(1,3) #结果[1,4]

内置函数reduce()

1. reduce(func 函数，序列[，初始值]
   将func函数作用于序列的元素，连续将现有结果和下一个元素作用在随后的结果上，最后返回单一值
2. reduce(lambda x,y:x+y,range(1,5)) #输出为10
3. from functools import reduce #reduce放入functools模块了

数据处理基础

Numpy数值运算

1. Numerical Python，高性能计算和数据分析的基础包
2. ndarray（n-dimensional array即多维数组）是其核心功能
3. 需要导入：import numpy as np
4. 快速创建数组，比使用基本库节省时间

1.数组的创建

print(np.array([1, 2, 3], dtype=float))
print(np.array([[1, 2, 3], [3, 5, 1]]))
print(np.arange(0, 3, 1))

print(np.repeat([1, 2], 2))
print(np.tile([1, 2], 2))

print(np.linspace(0, 3, 4)) #从0到3，共4个数，都是float
print(np.ones((2, 3))) #2行3列的1

print(np.random.random(3))  # 取3个0~1之间的随机数
print(np.random.randn(3))  # 取3个标准正态分布
print(np.random.normal(loc=0, scale=1, size=3))  # 取3个均值为0，标准差为1的正态分布

2.数组的索引与变换

# 2.索引变换
# []选定下标    按照[]内的数字来选定
# ：分隔        如果前后没有数则是全部数据
# ，不同维度    横轴，纵轴
# ···遍历剩下的维度
a = np.arange(6).reshape(3, 2)
print(a)  # 把原来的[0,1,2,3,4,5]改造成[[0,1],[2,3],[4,5]] 3行2列

索引

print(a[:, [0]])  # 纵轴，选取下标为0的所有列，即第一列

print(a[[0, 1], :])  # 横轴，选取下标为0的所有行，下标为1的所有行，即前两行

print(a[:, 1])  # 纵轴，选取下标为1的那一列
print(a[1, :])  # 横轴，选取下标为1的那一行
print(a[1, 1])  # 选取（1，1）这个元素

a = a.reshape(2, 3)  # 将原来3X2,改为2X3
print(a)

转置

 # 置换数组轴,需要a = 转置结果，不然实现不了
a = np.arange(6).reshape(3, 2)
print(a)  # 把原来的[0,1,2,3,4,5]改造成[[0,1],[2,3],[4,5]] 3行2列
a = np.transpose(a) 
print(a)

 # 置换数组轴,需要a = 转置结果，不然实现不了
a = np.arange(6).reshape(3, 2)
print(a)  # 把原来的[0,1,2,3,4,5]改造成[[0,1],[2,3],[4,5]] 3行2列
a = a.T
print(a)

print(a.flatten())  # 平迭展开,返回一份拷贝，对拷贝所作的修改不会影响原始矩阵
print(a.ravel())    # 平迭展开,返回视图，会影响原始矩阵

排序

# sort()直接返回排序后的数组
# argsort()返回数组排序后的下标
# msort()沿着第一个轴排序
# axis=0按列排序
# axis=1按行排序

a = np.array([3, 2, 5, 4])
print(a)
a = np.sort(a)
print(a)

a = np.array([3, 2, 5, 4])
print(a)
a.sort()
print(a)

#排完序后，元素对应的原来的下标
a = np.array([3, 2, 5, 4])
print(a)
temp = np.argsort(a)
print(temp)

#降序排序
a = np.array([3, 2, 5, 4])
print(a)
a = a[np.argsort(-a)]
print(a)

#按行或列排序
b = np.array([[1, 4, 3], [4, 5, 1], [2, 3, 2]])
print(b)
b.sort(axis=0)
print(b)

3.数组的组合

'''
水平组合hstack——把所有参加组合的数组拼接起来，各数组行数应相等
垂直组合vstack——追加，列数应相等
深度组户dstack
列组合colume_stack
行组合row_stack
'''
# 水平组合，下面三种方式结果都一样
a = np.arange(6).reshape(3, 2)
print(a)
b = np.arange(9).reshape(3, 3)
print(b)
d = np.hstack((a, b))
d = np.concatenate((a, b), axis=1)  # 按行排序
d = np.append(a, b, axis=1)
print(d)

b = np.arange(9).reshape(3, 3)
print(b)
c = np.arange(6).reshape(2, 3)
print(c)
# 垂直组合，下面三种方式结果都一样
d = np.vstack((b, c))
print(d)
d = np.concatenate((b, c), axis=0)
print(d)
d = np.append(b, c, axis=0)
print(d)

d = np.append(a, c)
print(d)

4.数组的统计函数

a = np.arange(6)
# 平均值、加权平均值
print(np.mean(a))
print(np.average(a))

方差是在概率论和统计方差衡量随机变量或一组数据时离散程度的度量

print(np.var(a))  # 计算方差

print(np.std(a))  # 计算标准差

print(np.argmin(a))
print(np.argmax(a))
print(np.ptp(a))  # 计算最大最小值之差

print(np.percentile(a, 90))  # 计算百分位在统计对象中的值
print(np.median(a))  # 中值
print(np.sum(a))

Pandas表格处理

import pandas as pd

Series数据结构

'''
Series数据结构
保存一维数据，含索引的一维数组
包含一个自动生成的index（可手动)和values，可以使用.index、.values查看
index返回一个index对象，values返回一个array
内部向量化运行，更快
'''
s = pd.Series([1, 3, 2, 4])
print(s.index)
print(s.values)

s = pd.Series([1, 3, 2, 4], index=['a', 'b', 'c', 'd'])
print(s.index)
print(s.values)

DataFrame数据结构

'''
DataFrame数据结构
保存二维数据
类似Excel的数据框
'''
# 创建DataFrrame
# 用列表来创建
df = pd.DataFrame([['a', 1, 2], ['b', 2, 5], ['c', 3, 3]], columns=['x', 'y', 'z'])  # 指定列的名称
print(df)
# 用数组来创建
df = pd.DataFrame(np.zeros((3, 3)), columns=['x', 'y', 'z'])  # （（））生成的是二维数组
print(df)
# 使用字典创建，键——列索引，值就是列索引下的所有元素
df = pd.DataFrame({'x': ['a', 'b', 'c'], 'y': range(1, 4), 'z': [2, 5, 3]})
print(df)
df = pd.DataFrame(dict(x=['a', 'b', 'c'], y=range(1, 4), z=[2, 5, 3]))
print(df)

# 数据的选取
df = pd.DataFrame({'x': ['a', 'b', 'c'], 'y': range(1, 4), 'z': [2, 5, 3]})
print(df)
# 1.选取某一列
print(df['y'])
print(df.y)
print(df.loc[:, ['y']])
print(df.iloc[:, [1]])

# 2.选取某一行
'''
取列：df.y=df['y]、dy.x=df['x']表示取y那一列，x那一列
x y只是列名，没有实际的值
选取行的时候就不能用上面的表达式
取行：按照数字来取
'''
# 2.选取某一行
print(df['x']) #取的是列不是行了
print(df.x)
print(df.loc[1, :])
print(df.iloc[1, :])

# 3.选取多列
print(df[['x', 'y']])  # 外层[]是整个二维，内层[]是一维
print(df.loc[:, ['x', 'y']])
print(df.iloc[:, [0, 1]])

# 4.选取多行
print(df.loc[[0, 1], :])

# 5.选取某一个元素
print(df.loc[1, 'y'])  # 下标为1，列名为y的
print(df.iloc[1, 1])  # （1，1）

'''
网格分布型数据的创建——三维插值展示
numpy中的meshgrid函数:x,y = meshgrid(a,b)
输入两个一维数组，输出两个二维数组x,y。其中矩阵x的行向量是向量a的简单复制，而矩阵y的列向量是向量b的简单复制。
'''
a = ['A', 'B', 'C']
b = [5, 7, 9]

X, Y = np.meshgrid(a, b)
print(X)
print(Y)
df_grid = pd.DataFrame({'x': X.flatten(), 'y': Y.flatten()})
print(df_grid)

Categorical数据类型

'''
Categorical:分类
干什么:用于承载基于整数的类别展示/编码的数据
类别:类别型、有序型
看作：包含了额外信息的列表，额外信息——不同的类别
决定了数据的分析方式以及如何进行视觉呈现
'''
# 1.分类数据的创建
cut = ['Fair', 'Good', 'Very Good', 'Premium', 'Ideal']
cut_1 = pd.Categorical(cut)  # 默认以字母顺序创建
# print(cut_1)
# 在创建时修改依字母创建的顺序
cut_2 = pd.Categorical(['Fair', 'Good', 'Very Good', 'Premium', 'Ideal'],
                       categories=['Good', 'Fair', 'Very Good', 'Ideal', 'Premium'], ordered=True)
# print(cut_2)

# 2.类别的更改：对于已经创建的分类数据库或数据框
# *.astype()指定类别选项覆盖默认排序
from pandas.api.types import CategoricalDtype

cut = pd.Series(['Fair', 'Good', 'Very Good', 'Premium', 'Ideal'])
cut_2 = cut.astype(CategoricalDtype(categories=['Good', 'Fair', 'Very Good', 'Ideal', 'Premium'], ordered=True))

# 3.类型的转换：获得categories和codes
print(cut_1.codes)
print(cut_1.categories)
print(cut_2.codes)
print(cut_2.categories)

# 从另一个数据源获得分类编码数据
categories = ['Fair', 'Good', 'Ideal']
codes = [0, 1, 2, 0, 0, 1]
cut_3 = pd.Categorical.from_codes(codes, categories)
print(cut_3)

表格的变换

'''
表格的变换
pd.melt()：将二维数据列表转成一维数据列表
'''
df = pd.DataFrame({'x': ['a', 'b', 'c'], '2010': [1, 3, 4], '2011': [3, 5, 2]})
df_melt = pd.melt(df, id_vars='x', var_name='year',value_name='value')
# id_vars='x'由标识变量构成的向量，用于标识观测的变量
# var_name='year'——变量year在中间
# value_name='value'——原始值，在第三个
print(df)
print(df_melt)

# 将长数据转换为宽数据
df_pivot = df_melt.pivot_table(index='x', columns='year', values='value')
df_pivot = df_pivot.reset_index()
print(df_pivot)

变量的变换

'''
变量的变换——处理某列的每个元素并生成新列
apply：操作的是DataFrame的某一列或某一行
applymap：作用于每个DataFrame的每个数据
map：对Series中的每个数调用一次函数
'''
df_melt['value2'] = df_melt['value'] * 2  # 左边待生成的新列，右边对原数据的操作
print(df_melt)
df_melt['value2'] = df_melt.apply(lambda x: x['value'] * 2 if x['year'] == '2011' else x['value'], axis=1)
print(df_melt)

表格的排序

'''
表格的排序
sort_values()
'''
dat_sort1 = df_melt.sort_values(by='value', ascending=True)  # 根据数据框的某列数值对整个表进行排序，ascending是上升的意思，True即升序
dat_sort2 = df_melt.sort_values(by='value', ascending=False)
dat_sort3 = df_melt.sort_values(by=['year', 'value'], ascending=True)
print(dat_sort1)
print(dat_sort2)
print(dat_sort3)

表格的拼接

'''
表格的拼接
新列、新行——pd.concat()
添加表格——append()
'''
df1 = pd.DataFrame(dict(x=['a', 'b', 'c'], y=range(1,4)))
df2 = pd.DataFrame(dict(z=['B', 'D', 'H'], g=[2, 5, 3]))
df3 = pd.DataFrame(dict(x=['g', 'd'], y=[2, 5]))
dat_cbind = pd.concat([df1, df2], axis=1)  # 横着添加列或横向添加表格
print(dat_cbind)

dat_cbind = pd.concat([df1, df3], axis=1)  # 横着添加列或横向添加表格
print(dat_cbind)
dat_rbind = pd.concat([df1, df3], axis=0)  # 竖着添加行或者纵向添加表格
dat_rbind = df1.append(df3)
print(dat_rbind)

'''
删除某行/列
labels：删除行/列的名字
axis默认为0，删除行
index指定要删除的行
columns指定删除的列
inplace=False默认不改变原数据而返回新的DataFrame
inplace=True直接在原数据上删除且无法返回
'''
print(df1)
df1.drop(columns='y', inplace=True)  # ，删除y列
print(df1)

表格的融合

'''
表格的融合
两个数据框需要一个共同的列才能拼接
pd.merge()不同参数可以实现不同的表格融合效果
两个表格融合会用缺失值NA代替不存在的值
'''
df1 = pd.DataFrame(dict(x=['a', 'b', 'c'], y=range(1, 4)))
df2 = pd.DataFrame(dict(x=['a', 'b', 'd'], z=range(4, 7)))
df3 = pd.DataFrame(dict(g=['a', 'b', 'd'], z=range(4, 7)))
df4 = pd.DataFrame(dict(x=['a', 'b', 'd'], y=[1, 4, 2], z=range(4, 7)))
print(df1)
print(df2)
print(df3)
print(df4)

# left设置左边的表，right设置右边的表，how设置时融合发生冲突以哪边为准，on匹配哪列
m1 = pd.merge(left=df1, right=df2, how='left', on='x')  # 只保留左表的所有数据
m2 = pd.merge(left=df1, right=df2, how="right", on='x')  # 只保右表

m3 = pd.merge(left=df2, right=df3, how='inner', on='z')  # inner只保留公共部分
m4 = pd.merge(left=df1, right=df2, how='outer', on='x')  # outer保留所有信息

m5 = pd.merge(left=df1, right=df4, how='left', on=['x', 'y'])  # 多列匹配
m6 = pd.merge(left=df1, right=df3, how='left', left_on='x', right_on='g')  # 根据两个表的不同列名合并

# 两表有相同列名但是值不一样，合并时都保留就用suffixes给他们加后缀
m7 = pd.merge(left=df1, right=df4, how='left', on='x', suffixes=['.1', '.2'])
print(m7)

表格的分组操作

'''
某列包含多个类别的数据需要分出来
Pandas中DataFrame的一列就是一个Series
'''
df = pd.DataFrame({'x': ['A', 'B', 'C', 'A', 'C'], '2010': [1, 3, 4, 4, 3], '2011': [3, 5, 2, 8, 9]})
df_melt = pd.melt(df, id_vars=['x'], var_name='year', value_name='value')
# print(df_melt)
# 按行/列操作：
df_rowsum = df[['2010', '2011']].apply(lambda x: x.sum(), axis=1)  # 按行
df_colsum = df[['2010', '2011']].apply(lambda x: x.sum(), axis=0)  # 按列
print(df_rowsum)
print(df_colsum)
df['2010_2'] = df['2010'].apply(lambda x: x + 2)  # 单列可用map和apply,相当于给df添加了一列2010_2的数据
print(df['2010_2'])
print(df)
df['2010_2011'] = df.apply(lambda x: x['2010'] + 2 * x['2011'], axis=1)  # 多列可用apply，相当于添加一列2010_2011
print(df)
print(df['2010_2011'])

# 分组操作：groupby()
df_groupe_mean1 = df_melt.groupby('year').mean()  # 按year分组求均值
print(df_groupe_mean1)
df_groupe_mean2 = df_melt.groupby(['year', 'x'],
                                  as_index=False).mean()  # 按多个列求均值，as_index=False表示不会将['year','x']两列设定为索引列
print(df_groupe_mean2)
df_group_sum = df_melt.groupby('year').sum()  # 按year分组求和
print(df_group_sum)
df_group_std = df_melt.groupby('year').std()  # 按year分组求方差
print(df_group_std)

# aggregate()分组聚合
df_group1 = df_melt.groupby(['x', 'year']).agg({np.mean, np.median})
df_group2 = df_melt.groupby(['x', 'year'], as_index=False).agg({np.mean, np.median})
print(df_group1)
print(df_group2)

# 分组运算
df_melt['percentage'] = df_melt.groupby('x')['value'].transform(lambda x: x / x.sum())
print(df_melt)
# 分组筛选：
df_filter = df_melt.groupby('x').filter(lambda x: x['value'].mean() > 4)
print(df_filter)

为什么有3，2？是说这里面只有(4+3+2+9)/4=4.5>4的吗？

数据的导入与导出

'''
数据的导入与导出
（1）CSV格式数据的导入/导出
pd.read_csv():读入CSV格式的数据并以DataFrame形式存储
导入的数据存储中文字符时要注意
列之间的分割方式设定delimiter（默认空格）参数，大于一个字符的分隔符被看作正则表达式
*.to_csv(),将DataFrame转成CSV文件，index=False表示忽略索引信息，index=True表示输出文件的第一列保留索引值
特点：
1.文件结构简单，基本和TXT差别不大
2.可以和Excel进行转换，其文件存储大小比Excel小
3.简单的存储方式，减少存储信息的容量，有利于网络传输及客户端的再处理
4.没有任何说明，具备基本的安全性
'''
df = pd.read_csv("Data.csv", sep=",", header=0, index_col=None, encoding="utf-8")
df.to_csv("Data.csv", index=False, header=False)

'''
(2)TXT格式数据的导入与导出
np.loadtxt():将电子表格存储在TXT文件中：读取数据并存储为ndarray，在使用pd.DataFrame转换成DataFrame格式的数据
TXT的每一行都要含有相同数量的数据
np.savetxt(fname,X):将ndarray数组保存为TXT格式的文件，其中参数fname为文件名，X为需要保存的数组
'''
df = pd.DataFrame(np.loadtxt('Data.txt', delimiter=','))
'''
Excel文件格式的导入与导出
pd.read_excel()
to_excel()
导入的是二维列表则用pd.melt()将其转换成一维
'''
df = pd.read_excel("data.xlsx", sheet_name='sheetname', header=0)  # sheetname默认为0，header指定列名行，默认0第一行
df.to_excel(excel_writer='目标路径', sheet_name='sheetname', index=False)  # 忽略索引

判断一维列表还是二维列表：
看列：每一列是独立参数则一维，每一列都是同类参数则二维。

缺失值的处理

'''
缺失值的处理
np.nan表示缺失值
'''
df_NA1 = df.dropna(axis=0)  # 直接删除带NaN的行
df_NA2 = df.fillna(method="ffill")  # 使用最邻近的元素填充NaN
df_3 = df.fillna(2)  # 使用指定的数值代替NaN

理解

添加列时用axis=1(横）：横着给每一行最后添加
添加行使用axis=0（纵）：竖着给每一列添加