pandas数据分析——常见函数查看数据

通用流程：

1. 数据读取
2. 数据存储结构查看（是Series格式 还是 DataFrame格式），列表头，行表头。
3. 使用一些函数查看数据分布、缺失、异常，等

数据读取

（点击查看详细读取操作）

import pandas as pd
path = r"F:\joyful-pandas-master\data\learn_pandas.csv"
df = pd.read_csv(path, encoding="gbk")

数据存储结构查看及表头含义

（pandas数据类型查看）

import pandas as pd
path = r"F:\joyful-pandas-master\data\learn_pandas.csv"
df = pd.read_csv(path, encoding="gbk")
print(type(df))
print(df.columns)
print(df.index)

常见函数查看数据

基本汇总信息

介绍：head() ， tail() ， info() ， describe() ，

# 查看前几行数据
print(df.head(3))  # 默认值是前 5 行
# 查看后几行数据
print(df.tail(3))  # 默认值是后 5 行
# 查看数据介绍（基本信息）
print(df.info())
# 查看统计量（总数，平均值，方差，等等）
print(df.describe())

数据特征的统计函数

功能	使用方法
求和	pd格式变量名.sum()
平均值	pd格式变量名.mean()
中位数	pd格式变量名.median()
方差	pd格式变量名.var()
标准差	pd格式变量名.std()
最大值	pd格式变量名.max()
最小值	pd格式变量名.min()
分位数	pd格式变量名.quantile()
统计没有缺失数据的个数	pd格式变量名.count()
最大值相应的索引	pd格式变量名.idxmax()
最小值相应的索引	pd格式变量名.idxmin()

记忆方法：

variance = 变化幅度--》方差
standard = 标准 --》标准差
quantile = 分位数  （含义：n分位数 就是 把随机变量的概率分布分成 n 等份.）
count = 计数（无缺失值）
idxmax = index of max 最大值相应索引

上面的这些方法均有一个共同的属性值：
axis = 0 或者 1
axis = 轴线方向

轴线方向	代表含义
axis = 0	结果为列的统计指标
axis = 1	结果为行的统计指标

唯一值函数

唯一 === 只有一个
值 === 元素
唯一值函数 === 一个元素只出现一次

功能	使用方法
唯一值函数	pd格式变量名.unique()
统计唯一元素数量的函数	pd格式变量名.nunique()
唯一值函数 + 唯一值元素个数	pd格式变量名.value_counts()

import pandas as pd
data = pd.Series(data=[1, 2, 3, 1, 1, 1, 2, 2, 2])
print(data.unique())
print(data.nunique())

运行结果：

[1 2 3]
3

2    4
1    4
3    1

记忆：

unique = 独有的；独特的；唯一的
nunique = number of uniqueness 独有元素的个数（去重后的元素的数量，出现次数）

value_counts() 的用法：

import pandas as pd
data = pd.Series(data=["a", "a", "b", "b", "c", "d", "d"])
print(data.value_counts())

运行结果:

元素值	  频次（从大到小排列）
b 		   2
d   	   2
a   	   2
c   	   1

以上是单个类别的唯一值函数 及 个数统计函数。
如果数据量不止一个类别，且我们需要观测多种类别的唯一值，这时候一个一个使用unique() 函数是不方便的。
此处引入：观测多个类别下，对应的唯一值。
drop_duplicates() = unique() 方法的集合
使用举例：

import pandas as pd
path = r"F:\joyful-pandas-master\data\learn_pandas.csv"
df = pd.read_csv(path, encoding="gbk")

df_demo = df[["Gender", "Height", "Weight"]]
df_demo.drop_duplicates(["Gender", "Height"])

运行结果：

print(df_demo)  原始数据运行结果
     Gender  Height  Weight
0    Female   158.9    46.0
1      Male   166.5    70.0
2      Male   188.9    89.0
3    Female     NaN    41.0
4      Male   174.0    74.0
..      ...     ...     ...
195  Female   153.9    46.0
196  Female   160.9    50.0
197  Female   153.9    45.0
198    Male   175.3    71.0
199    Male   155.7    51.0

[200 rows x 3 columns]

print(df_demo.drop_duplicates(["Gender", "Height"]))
     Gender  Height  Weight
0    Female   158.9    46.0
1      Male   166.5    70.0
2      Male   188.9    89.0
3    Female     NaN    41.0
4      Male   174.0    74.0
..      ...     ...     ...
193    Male   193.9    79.0
195  Female   153.9    46.0
196  Female   160.9    50.0
198    Male   175.3    71.0
199    Male   155.7    51.0
[148 rows x 3 columns]

通过比对  行总数 * 列总数 可知，这里已经将重复的元素剔除掉了。
drop_duplicates = 去除__复制  --> 去除重复的元素

drop_duplicates() 括号中有3个参数：

变量名.drop_duplicates( 筛选类别, keep = 'first'或'last'或False, inplace=False)
输出值 是  去除重复的元素的数据集合（≈ 数据序列）

如果keep = False 表示 保留只出现一次的符合筛选类别的数据。

替换函数

映射替换（有对应关系的替换方式）

replace = 替换
替换操作是针对某一个列进行的。

数学减法： 
	被减数  -  减数  =  差
替换方法：
	被取代的量或类  -  要上位的量或类  =  新的数据表达

举例：

df["Gender"].head()	 # 原数据
df["Gender"].replace({"Female": "a", "Male": "b"}).head()

运行结果：

原数据运行结果：
0    Female
1      Male
2      Male
3    Female
4      Male
替换后的运行结果：
0    a
1    b
2    b
3    a
4    b

该替换方法的等价写法有：

df["Gender"].replace({"Female": "a", "Male": "b"}).head()  # 字典形式对应
df["Gender"].replace(['Female', 'Male'], ["a", "b"]).head()  #列表形式对应

replace()方法及参数

pd变量名.replace(被替换内容与要上位内容，method = "ffill" 或 "bfill")
ffill  =  forward fill  用前一个临近的元素进行替换
bfill  =  back fill  用后面一个临近的元素进行替换

使用方法举例：

s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
s_new = s.replace([1, 2], method="ffill")
print(s)
print(s_new)

运行结果：

print(s)  这表示 执行replace() 方法后，原变量不变，产生的是新变量
0    a
1    1
2    b
3    2
4    1
5    1
6    a
print(s_new)
0    a
1    a
2    b
3    b
4    b
5    b
6    a

#解释：

replace([1, 2], method="ffill") 
被替换的内容是一定要写的， 要上位的内容可以有 method 确定
此处： [1, 2] 是 被替换的内容， 方法是用 ffill 前面的元素替换掉[1, 2]

数值替换

数值替换类型	使用方法
取整	变量名.round(保留几位小数)
取绝对值	变量名.abs()
截断	变量名.clip(截取下边界数值，上界)

注意：clip(下界， 上界) 均可以取到(包含在内)，属于闭区间

import pandas as pd
s = pd.Series([1, 3, 4, -0.2200222, -4.66])

s_new_round = s.round(2)
s_new_abs = s.abs()
s_new_clip = s.clip(1, 4)
print(s_new_round)
print("**"* 3)
print(s_new_abs)
print("**"* 3)
print(s_new_clip)

运行结果：

print(s_new_round)
0    1.00
1    3.00
2    4.00
3   -0.22
4   -4.66
dtype: float64
******
print(s_new_abs)
0    1.000000
1    3.000000
2    4.000000
3    0.220022
4    4.660000
dtype: float64
******
print(s_new_clip)
0    1.0
1    3.0
2    4.0
3    1.0
4    1.0
dtype: float64

逻辑替换

.where() 和 .mask() :

方法	具体功能
变量名.where(判定条件)	传入条件为 False 的对应行进行替换
变量名.mask(判定条件)	传入条件为 True 的对应行进行替换

注意： 当不指定替换值时，替换为缺失值。

import pandas as pd
s = pd.Series([1, 3, 4, -0.2200222, -4.66])
s_new_where = s.where(s<0)
print(s_new_where)

s_new_mask = s.mask(s<0)
print(s_new_mask)

s_new_where_1 = s.where(s<0, "a")
print(s_new_where_1)

运行结果：
print(s_new_where)
0         NaN
1         NaN
2         NaN
3   -0.220022
4   -4.660000
dtype: float64
print(s_new_mask)
0    1.0
1    3.0
2    4.0
3    NaN
4    NaN
dtype: float64
print(s_new_where_1)
0           a
1           a
2           a
3   -0.220022
4       -4.66
dtype: object

注意： 这里的 dtype: object 指的是 数据的混合类型。

排序函数

sort = 整理，把……分类， --> 排序
其实python中也有排序函数：

sort() 函数 和 .sorted() 函数
两者均可以给数值型变量 和 字符型变量 排序
具体可以查看：（请点击查看）

pandas中有按值排序sort_value() , 按下标排序sort_index()
使用方法：
1. 导入库，并读取数据
2. 筛选数据，并设置下标：.set_index()方法
3. 用方法sort_value() 或 sort_index()进行排序
4. 设置排序的限制条件
实战演练：

import pandas as pd
path = r"F:\joyful-pandas-master\data\learn_pandas.csv"
df = pd.read_csv(path, encoding="gbk")

df_demo = df[["Gender", "Name", "Height"]].set_index(["Gender", "Name"])
df_demo_Height = df_demo.sort_values("Height", ascending=False).head()
print(df_demo_Height)

运行结果：

                      Height
Gender Name                 
Male   Xiaoqiang Qin   193.9
       Mei Sun         188.9
       Gaoli Zhao      186.5
       Qiang Han       185.3
       Qiang Zheng     183.9

解释：ascending = 提升，登高，升高

ascending	作用
ascending = True	从小到大排序（提升，登高）
ascending = False	从大到小排序

还可以多组类别并行进行排序（ 类似于多个窗口打饭 ）
实战演练：

import pandas as pd
path = r"F:\joyful-pandas-master\data\learn_pandas.csv"
df = pd.read_csv(path, encoding="gbk")

df_demo = df[["Gender", "Name", "Height"]].set_index(["Gender", "Name"])
df_demo = df[["Gender", "Name", "Height", "Weight"]].set_index(["Gender", "Name"])
df_demo_Height_Weight = df_demo.sort_values(["Height", "Weight"], ascending=[False, True]).head()
print(df_demo_Height_Weight)

运行结果：

                      Height  Weight
Gender Name                         
Male   Xiaoqiang Qin   193.9    79.0
       Mei Sun         188.9    89.0
       Gaoli Zhao      186.5    83.0
       Qiang Han       185.3    87.0
       Qiang Zheng     183.9    87.0

apply() 应用函数的方法

变量名.apply(要执行的限定函数)
限定函数 = 自定义的函数，根据需要自行定义

apply 方法常用于 DataFrame 的行迭代或者列迭代

import pandas as pd
path = r"F:\joyful-pandas-master\data\learn_pandas.csv"
df = pd.read_csv(path, encoding="gbk")

df_demo = df[["Gender", "Name", "Height", "Weight"]].set_index(["Gender", "Name"])
df_demo_Height_Weight = df_demo.sort_values(["Height", "Weight"], ascending=[False, True]).head()

new_mean = df_demo_Height_Weight.apply(lambda x: x.mean())
print(new_mean)

运行结果：

Height    187.7
Weight     85.0
dtype: float64

解释：

变量名.apply(要执行的限定函数）-->生成了新的变量，没有对原数据进行改变