pandas&numpy 数据处理~~两万字超全
文章目录
- numpy
-
- 1. numpy属性
- 2. 创建array
- 3. numpy基础运算
-
- 3.1 一维序列运算
- 3.2 二维矩阵运算
- 3.3 排序
- 4. numpy的索引
-
- 4.1 一维序列
- 4.2 二维矩阵
- 5. 循环矩阵
- 6. array的合并
- 8. array 分割
- 9. numpy copy & deep copy
- pandas
-
- 1. pandas安装
- 2. 数据结构 - Series
- 3. 数据结构 - DataFrame
- 4. 创建DataFrame
-
- 4.1 使用列表创建
- 4.2 使用ndarrays 建
- 4.3 使用字典创建
- 4.4 实例 - loc
- 5. pandas - csv文件
-
- 导入文件
- 6. pandas - 数据处理
-
- 6.1 head()
- 6.2 tail()
- 6.3 info()
- 7. pandas JSON
- 8. pandas - **数据清洗**
-
- 8.1 pandas 清洗空值
- 8.2 pandas清洗格式错误数据
- 8.3 pandas 清洗错误数据
- 8.5 pandas 清洗重复数据
numpy
1. numpy属性
- 判断矩阵维度：
array.ndim - 判断矩阵形状：
array.shape - 判断矩阵元素个数：
array.size
#导入numpy
import numpy as np
#创建矩阵
array = np.array([[1,2,3],
[3,4,5],
[2,3,4]
])
print(array)
输出：
[[1 2 3]
[3 4 5]
[2 3 4]]
# 几维数组
print('number of dim',array.ndim) # number of dim 2
# 形状，几行几列数组
print('shape',array.shape) # shape (3, 3)
# size，一共有一个元素
print('size',array.size) # size 9
2. 创建array
- 创建一维序列：
a = np.array([1,2,3,4]） - 创建二位矩阵：
a = np.array([[1,2,3], [2,3,4]]) - 创建随机矩阵：
a = np.random.random((3,4))——(3,4)表示3行4列矩阵 - 创建一个全部为0 的矩阵：
a = np.zeros((3,4),dtype = np.int32)——(3,4)表示3行4列矩阵；dtype设置类型 - 创建一个全部为 1 的矩阵：
a = np.ones((3,4),dtype = np.int16) - 创建一个全部为 empty 的矩阵：
a = np.empty((3,4)) - 生成一个有序序列：
a = np.arange(12).reshape((3,4))——arange(12)表示0-11的数字，reshape()括号里填写几行几列 - 数据区间被分成线段：
a = np.linspace(1,10,6).reshape(2,3)——1-10的序列，被分为6段，reshape()定义几行几列
import numpy as np
# 1. 创建一维序列
a = np.array([1,2,3,4],dtype = np.int64) #dtype 用于查看类型，默认int32,
print(a, a.dtype) # 输出：[1 2 3 4] int64
print(a.shape) # 输出：(4,) ——表示序列，不是矩阵
# 2. 创建二维矩阵
a = np.array([[1,2,3],
[2,3,4]])
print(a)
输出：
[[1 2 3]
[2 3 4]]
# 3. 创建一个随机生成的矩阵
a = np.random.random((3,4)) #括号内指定行列数即可
print(a)
输出：
[[0.96913245 0.42265093 0.62387946 0.83842189]
[0.00910311 0.31142922 0.74050868 0.67094311]
[0.79450196 0.63776097 0.3371271 0.16052966]]
# 4. 创建一个全部为0 的矩阵
a = np.zeros((3,4),dtype = np.int32) # 括号里输入几行几列
print(a)
输出：
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
# 5. 创建一个全部为 1 的矩阵
a = np.ones((3,4),dtype = np.int16) # 括号里输入几行几列
print(a)
输出：
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
# 6. 创建一个全部为 empty 的矩阵
a = np.empty((3,4)) # 括号里输入几行几列，类型为float
print(a)
输出：
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
# 7. 生成一个有序序列
a = np.arange(12).reshape((3,4)) #reshape() 确定几行几列
print(a)
输出：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
# 8. 一个数据区间被分成线段
a = np.linspace(1,10,6).reshape(2,3) #1-10的序列，被分为5段,reshape()定义几行几列
print(a,a.dtype)
输出：
[[ 1. 2.8 4.6]
[ 6.4 8.2 10. ]] float64
3. numpy基础运算
3.1 一维序列运算
- 加法：c=a+b
- 减法：c=a-b
- 乘法：c=a**b(平方)
# 定义2个一维序列
a = np.array([10,20,30,40])
b = np.arange(4)
print(a)
print(b)
输出：
[10 20 30 40]
[0 1 2 3]
# 1. 减法
c= a-b
print(c)
输出：[10 19 28 37]
# 2. 加法
d = a+b
print(d)
输出：[10 21 32 43]
# 3. 乘法
e = b**2 # **代表平方
f =10*np.sin(a) # 调用numpy中sin函数
g = a*b # 对应相乘
print(e)
print(f)
print(g)
输出：
[0 1 4 9]
[-5.44021111 9.12945251 -9.88031624 7.4511316 ]
[ 0 20 60 120]
# 4. 判断矩阵中元素的大小
print(b)
print(b<3) # 矩阵b中元素是否小于3
print(b==3) # 矩阵b中元素是否小于3
输出：
[0 1 2 3]
[ True True True False]
[False False False True]
3.2 二维矩阵运算
- 矩阵乘法：
①c = a*b；逐个相乘，要求矩阵维度必须相同，2行2列与3行2列无法相乘
②c_dot = np.dot(a,b)或c_dot = a.dot(b)；矩阵a与矩阵b相乘
# 定义两个矩阵
a = np.array([
[0,1],
[2,1]
])
b = np.arange(4).reshape((2,2))
print(a)
print(b)
输出：
[[0 1]
[2 1]]
[[0 1]
[2 3]]
# 1. 矩阵乘法
c = a*b #对应位置相乘 要求矩阵维度必须相同，2行2列与3行2列无法相乘
print(c)
输出：
[[0 1]
[4 3]]
#矩阵相乘 - 1
c_dot = np.dot(a,b) #表达方式1
print(c_dot)
输出：
[[2 3]
[2 5]]
#矩阵相乘 - 2
c_dot_2 = a.dot(b) # 表达方式2
print(c_dot_2)
输出：
[[2 3]
[2 5]]
-
矩阵求和、求最大值、最小值
①求和：np.sum()
②最大值：np.max()
③最小值：np.min() -
求每行或者每列中的sum、最大、最小值
指定行或列用axis，axis = 1，对行操作；axis = 0，对列操作；
①矩阵中每行元素求和：np.sum(a,axis=1)
②矩阵中每列元素求最大值：np.max(a,axis = 0
③矩阵中每行元素求最小值：np.min(a,axis = 1)
# 创建一个随机生成的矩阵
a = np.random.random((2,4)) #括号内指定行列数即可
# 1. 求和、最大值、最小值
print(a)
输出：
[[0.40596249 0.55513475 0.6697611 0.27219617]
[0.21702995 0.78822072 0.74077249 0.45906168]]
print(np.sum(a)) #矩阵中所有元素求和
print(np.max(a)) #矩阵中所有元素的最大值
print(np.min(a)) #矩阵中所有元素的最小值
输出：
4.108139341201598
0.7882207190918352
0.2170299493607155
# 2. 求每行或者每列中的sum、最大、最小值
#定义axis,axis = 0,按照行求；axis = 0，按照列求
print(a)
输出：
[[0.40596249 0.55513475 0.6697611 0.27219617]
[0.21702995 0.78822072 0.74077249 0.45906168]]
print(np.sum(a,axis = 1)) #矩阵中每行元素求和
print(np.max(a,axis = 0)) #矩阵中每列的最大值
print(np.min(a,axis = 1)) #矩阵中每行的最小值
输出：
[1.90305451 2.20508483]
[0.40596249 0.78822072 0.74077249 0.45906168]
[0.27219617 0.21702995]
-
求矩阵中元素的最大数最小数对应索引：
①最小值对应索引：np.argmin(A)
②最大值对应索引：np.argmax(A) -
求所有元素的平均值：
①方法一：np.mean(A)
②方法二：A.mean()
③方法三：np.average(A) -
求每行或者每列的平均值：
np.mean(A,axis = 0 / 1)；
axis = 0——每一列的平均值；axis = 1——每一行的平均值 -
求所有元素的中位数：
np.median(A) -
求所有元素累加和：
np.cumsum(A) -
累差：
np.diff(A) -
非零数的位置：
np.nonzero(A)
A = np.arange(2,14).reshape((3,4))
print(A)
输出：
[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
# 4. 求矩阵中元素的最大数最小数对应索引
print(np.argmin(A)) # 求所有元素中最小数对应的索引
print(np.argmax(A)) # 求所有元素中最大数对应的索引
输出:
0
11
# 5. 求所有元素的平均值
print(np.mean(A))
print(A.mean())
print(np.average(A))
输出：
7.5
7.5
7.5
# 6. 求每行或者每列元素的平均值;axis=0,对列计算，axis=1，对行计算
print(np.mean(A,axis = 0))
print(np.mean(A,axis = 1))
输出：
[6. 7. 8. 9.]
[ 3.5 7.5 11.5]
# 7. 求所有元素的中位数
print(np.median(A))
输出：7.5
# 8. 求所有元素累加和
print(np.cumsum(A))
输出：
[ 2 5 9 14 20 27 35 44 54 65 77 90]
# 9. 累差
print(np.diff(A)) #由3行4列变为3行3列
输出：
[[1 1 1]
[1 1 1]
[1 1 1]]
# 10. 非零数的位置
print(np.nonzero(A))
输出：
(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
# 输出2个array，第一个array代表行索引，带二个array代表列索引：行索引为0，列索引为0,1,2,3的元素都非零
3.3 排序
- 每行都升序排序：
np.sort(A) - 转置矩阵：
A.T或np.transpose(A) - 转置后矩阵与转置前相乘：
(A.T).dot(A) - 截取——使用clip()函数，超出边界的元素，都变为边界数字
np.clip(A,5,11)—— A表示矩阵，5和11为边界；小于5的数字变为5，大于11的数字变为11
A=np.arange(14,2,-1).reshape(3,4)
print(A)
输出：
[[14 13 12 11]
[10 9 8 7]
[ 6 5 4 3]]
# 1. 每行升序排序
print(np.sort(A))
输出：
[[11 12 13 14]
[ 7 8 9 10]
[ 3 4 5 6]]
# 2. 转置矩阵 - 两种写法
print(A.T)
print(np.transpose(A))
均输出：
[[14 10 6]
[13 9 5]
[12 8 4]
[11 7 3]]
# 3. 转置后矩阵与转置前相乘
print((A.T).dot(A))
输出：
[[332 302 272 242]
[302 275 248 221]
[272 248 224 200]
[242 221 200 179]]
# 4. 截取clip()，超出边界的元素，都变为边界数字
print(np.clip(A,5,11)) #小于5的数字变为5，大于11的数字变为11
输出：
[[11 11 11 11]
[10 9 8 7]
[ 6 5 5 5]]
4. numpy的索引
4.1 一维序列
# 定义一个array
A = np.arange(3,15)
print(A)
输出：
[ 3 4 5 6 7 8 9 10 11 12 13 14]
# 1. 获取一维数组指定索引的元素值
print(A[3]) # 索引为 3 的值为6
输出：6
4.2 二维矩阵
- 获取二维数组指定索引的元素值：
array[行索引][列索引] - 获取某行、某列值：
array[行索引, 列索引]
# 定义一个array
A = np.arange(3,15).reshape((3,4))
print(A)
输出：
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
# 1. 获取二维数组指定索引的元素值
print(A[2][1]) #行索引为【2】，列索引为【1】对应的元素值
print(A[2,1])
输出：
12
12
# 2. 获取某行、某列值
print(A[2,:]) #行索引为2，所有列
print(A[2,0:2]) #行索引为2，列索引为0，1
print(A[:,2]) #所有行，列索引为2
输出：
[11 12 13 14]
[11 12]
[ 5 9 13]
5. 循环矩阵
for循环
## 1. 迭代每一行
for row in A:
print(row)
输出：
[3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]
## 2. 迭代每一列
# for col in A: #失败
# print(col)
print(A.T) #----转置A
输出：
[[ 3 7 11]
[ 4 8 12]
[ 5 9 13]
[ 6 10 14]]
for col in A.T: # 通过转置迭代
print(col)
输出：
[[ 3 7 11]
[ 4 8 12]
[ 5 9 13]
[ 6 10 14]]
## 3. 迭代出每个元素，先用flat迭代器将A平铺，再进行迭代
print(A.flatten()) #用flatten()返回的是array
输出：
[ 3 4 5 6 7 8 9 10 11 12 13 14]
for item in A.flat:
print(item)
输出：
3
4
5
6
7
8
9
10
11
12
13
14
6. array的合并
# 定义一个array
A = np.array([1,1,1])
B = np.array([2,2,2])
print('--------上下合并两个array——vatack()-----------')
C = np.vstack((A,B)) #vertical stack 上下合并
print(C)
print(A.shape,C.shape)
输出：
[[1 1 1]
[2 2 2]]
(3,) (2, 3)
print('--------左右合并两个array——hstack()-----------')
D = np.hstack((A,B)) # horizontal stack左右合并
print(D)
print(A.shape,D.shape)
输出：
[1 1 1 2 2 2]
(3,) (6,)
print('----------序列转置仍是序列--------------------')
print(A.T.shape) #(3,) 序列的转置仍是序列
输出：(3,)
print('----------------序列变为矩阵---------------')
print(A[:,np.newaxis])
print(A[:,np.newaxis].shape) # (3, 1) np.newaxis 给数组加一个维度
输出：
[[1]
[1]
[1]]
(3, 1)
print(A[np.newaxis,:])
print(A[np.newaxis,:].shape) #(1, 3)
输出：
[[1 1 1]]
(1, 3)
print('-----------------转为矩阵之后合并----------------------')
A1 = np.array([1,1,1])[:,np.newaxis]
B1 = np.array([2,2,2])[:,np.newaxis]
C1 = np.vstack((A,B)) #纵向合并
D1 = np.hstack((A,B)) #横向合并
print(C1)
输出：
[[1 1 1]
[2 2 2]]
print(D1)
输出：
[1 1 1 2 2 2]
print('------------多个array合并-------------------------')
A1 = np.array([1,1,1])[:,np.newaxis]
B1 = np.array([2,2,2])[:,np.newaxis]
C2 = np.concatenate((A1,B1,B1,A1),axis = 0) #可以在axis处定义合并方式，axis=0，纵向合并；axis=1横向合并
D2 = np.concatenate((A1,B1,B1,A1),axis = 1)
print(C2)
输出：
[[1]
[1]
[1]
[2]
[2]
[2]
[2]
[2]
[2]
[1]
[1]
[1]]
print(D2)
输出：
[[1 2 2 1]
[1 2 2 1]
[1 2 2 1]]
8. array 分割
- 对等分割：
np.split() - 不等量分割：
np.array_split()
#创建array
A = np.arange(12).reshape((3,4))
print(A)
输出：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
print('------------对等分割 np.split()-------------------')
print(np.split(A,3,axis = 0)) # split(对哪个array分割，分割成几块，axis=0/1)；axis=0,对列操作，每列分为几块，合并到一块；axis=1，对行操作，玫红分为几块，再和一块
输出：
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
print(np.split(A,2,axis = 1))
输出：
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
print('---------------不等量分割 np.array_split()------------------')
print(np.array_split(A,3,axis = 1))
输出：
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
print(np.vsplit(A,3)) #上下分割
输出：
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
print(np.hsplit(A,2)) #左右分割
输出：
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
9. numpy copy & deep copy
# 定义一个array
a = np.arange(4)
print(a)
输出：
[0 1 2 3]
b = a
c = a
d = b
a[0]=11
a
输出：array([11, 22, 0, 3])
b is a #判断a与b是否相等
输出：True
d[1:3]=[22,33]
a
输出：array([11, 22, 33, 3])
# 把a的值赋给b，但不关联，改变a的值，b不变
print(a)
b = a.copy() # deep copy
a[2]=33
print(a)
print(b)
输出：
[ 0 1 11 3]---a
[ 0 1 33 3]---a'
[ 0 1 11 3]---b
pandas
1. pandas安装
-
使用 pip 安装 pandas:
pip install pandas
具体可见：
pandas&numpy安装 -
安装成功后，我们就可以导入 pandas 包使用：
import pandas as pd
- 事例
import pandas as pd
# 查看pandas版本
pd.__version__ ## 输出：'1.4.3'
# 实例
import pandas as pd
mydataset = {
'sites': ["Google", "Runoob", "Wiki"],
'number': [1, 2, 3]
}
myvar = pd.DataFrame(mydataset)
print(myvar)
# 输出结果如下图：
2. 数据结构 - Series
-
Pandas Series 类似表格中的一个列（column），类似于一维数组，可以保存任何数据类型。
-
Series 由索引（index）和列组成，函数如下：
pandas.Series( data, index, dtype, name, copy)
参数说明：
data：一组数据(ndarray 类型)。
index：数据索引标签，如果不指定，默认从 0 开始。
dtype：数据类型，默认会自己判断。
name：设置名称。
copy：拷贝数据，默认为 False。 -
实例
import pandas as pd
a = [1, 2, 3]
myvar1 = pd.Series(a)
print(myvar1)
# 输出结果如下图：
3. 数据结构 - DataFrame
-
DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。
-
DataFrame 构造方法如下：
pandas.DataFrame( data, index, columns, dtype, copy)
参数说明：
data：一组数据(ndarray、series, map, lists, dict 等类型)。
index：索引值，或者可以称为行标签。
columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。
dtype：数据类型。
copy：拷贝数据，默认为 False。
4. 创建DataFrame
4.1 使用列表创建
import pandas as pd
data = [['Google',10],['Runoob',12],['Wiki',13]]
df = pd.DataFrame(data,columns=['Site','Age'],dtype=float)
print(df)
# 输出结果如下图：
4.2 使用ndarrays 建
以下实例使用 ndarrays 创建，ndarray 的长度必须相同， 如果传递了 index，则索引的长度应等于数组的长度。如果没有传递索引，则默认情况下，索引将是range(n)，其中n是数组长度。
import pandas as pd
data = {'Site':['Google', 'Runoob', 'Wiki'], 'Age':[10, 12, 13]}
df = pd.DataFrame(data)
print (df)
# 输出结果如下图：
4.3 使用字典创建
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
df
# 输出结果如下图：
没有对应的部分数据为 NaN。
4.4 实例 - loc
- 实例1——返回指定行数据
使用loc属性返回指定行的数据，如果没有设置索引，第一行索引为 0，第二行索引为 1，以此类推：
part1: 输出单行数据
import pandas as pd
data={
'calories':[420,380,390],
'duration':[50,40,45]
}
# 数据载入到DataFrame
df=pd.DataFrame(data)
# 返回第一行
print(df.loc[0])
# 返回第二行
print(df.loc[1])
# 输出结果如下图：
注意：返回结果其实就是一个 Pandas Series 数据。
part2: 输出多行数据
# 返回第一行和第二行
print(df.loc[[0, 1]])
# 输出结果如下图：
注意：返回结果其实就是一个 Pandas DataFrame 数据。
- 实例2——指定索引值
import pandas as pd
data = {
'calories':[20,30,40],
'duration':[50,40,45]
}
# 指定索引值
df = pd.DataFrame(data,index=['day1','day2','day3'])
df
#输出结果如下图：
- 实例3——返回指定索引-对应到某一行
Pandas 可以使用loc属性返回指定索引-对应到某一行：
import pandas as pd
data = {
'calories':[20,30,40],
'duration':[50,40,45]
}
# 指定索引值
df = pd.DataFrame(data,index=["day1","day2","day3"])
# 指定索引
print(df.loc["day2"])
# 输出结果如下图：
5. pandas - csv文件
-
CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）。
CSV 是一种通用的、相对简单的文件格式，被用户、商业和科学广泛应用。 -
以“match.csv"为例，我所使用的编辑器为“jupyter notebook”，安装教程见链接：jupyter notebook安装教程
如需csv文件，可以私信我。
导入文件
jupyter notebook 点击右上角“upload”，选择要导入的文件，上传即可。
读取数据：
import pandas as pd
df = pd.read_csv('match.csv') # 注意文件要用引号引起来
df
# 输出结果如下：
用to_string()返回DataFrame类型数据：
import pandas as pd
df = pd.read_csv('match.csv')
print(df.to_string()) #to_string() 用于返回 DataFrame 类型的数据，如果不使用该函数，则输出结果为数据的前面 5 行和末尾 5 行，中间部分以 ... 代替。
# 输出结果如下图：
实例： 使用to_csv将 DataFrame 存储为 csv 文件：输入如下代码，运行后便可以在jupyter notebook首页看到保存后的CSV文件
import pandas as pd
#三个字段 name,site,age
nme = ["Goole","Runboo","Tabao","Wiki"]
st = ["www.google.com", "www.runoob.com", "www.taobao.com", "www.wikipedia.org"]
ag = [90,40,80,98]
#字典
dict = {'name':nme,'site':st,'age':ag}
df = pd.DataFrame(dict)
#保存 dataframe
df.to_csv('site.csv')
6. pandas - 数据处理
6.1 head()
head( n ) 方法用于读取前面的 n 行，如果不填参数 n ，默认返回 5 行。
# 读取前五行
import pandas as pd
df = pd.read_csv("match.csv")
df.head(5)
6.2 tail()
tail( n ) 方法用于读取尾部的 n 行，如果不填参数 n ，默认返回 5 行，空行各个字段的值返回 NaN。
import pandas as pd
df = pd.read_csv("match.csv")
#读取末尾10行
df.tail(10)
6.3 info()
info() 方法返回表格的一些基本信息：
import pandas as pd
df = pd.read_csv('match.csv')
df.info()
# 输出结果如下：
non-null 为非空数据，我们可以看到上面的信息中，总共 458 行，College 字段的空值最多。
7. pandas JSON
- JSON（JavaScript Object Notation，JavaScript 对象表示法），是存储和交换文本信息的语法，类似 XML。
JSON 比 XML 更小、更快，更易解析。
实例1——以sites.json为例
# 保存文件
import pandas as pd
data=[
{
"id": "A001",
"name": "菜鸟教程",
"url": "www.runoob.com",
"likes": 61
},
{
"id": "A002",
"name": "Google",
"url": "www.google.com",
"likes": 124
},
{
"id": "A003",
"name": "淘宝",
"url": "www.taobao.com",
"likes": 45
}
]
df=pd.DataFrame(data)
df.to_json("sites.json")
# 读取文件，输出
df=pd.read_json("sites.json")
print(df.to_string())
# 结果如下：
实例2——将 Python 字典转化为 DataFrame 数据
JSON 对象与 Python 字典具有相同的格式，所以我们可以直接将 Python 字典转化为 DataFrame 数据：
import pandas as pd
#将字典格式的JSON
s={
"col1":{"row1":1,"row2":2,"row3":3},
"col2":{"row1":"x","row2":"y","row":"z"}
}
#读取JSON转为DataFrame
df=pd.DataFrame(s)
print(df)
#输出结果如下图：
实例3 ——从 URL 中读取 JSON 数据：
import pandas as pd
URL = 'https://static.runoob.com/download/sites.json'
df = pd.read_json(URL)
print(df)
#结果如下图：
8. pandas - 数据清洗
数据清洗是对一些数据集存在数据缺失、数据格式错误、错误数据或重复数据的情况进行处理，如果要对使数据分析更加准确，就需要对这些没有用的数据进行处理。
*以“property-data.csv”为例，如需文件请私信。 *
表中包含四种空数据：n/a 、NA 、— 、na
8.1 pandas 清洗空值
- 如果我们要删除包含空字段的行，可以使用 dropna() 方法，语法格式如下：
DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
参数说明：
axis：默认为 0，表示逢空值剔除整行，如果设置参数 axis＝1 表示逢空值去掉整列。
how：默认为 ‘any’ 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how=‘all’ 一行（或列）都是 NA 才去掉这整行。
thresh：设置需要多少非空值的数据才可以保留下来的。
subset：设置想要检查的列。如果是多个列，可以使用列名的 list 作为参数。
inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据。
- 实例1——通过 isnull() 判断各个单元格是否为空
import pandas as pd
df = pd.read_csv('property-data.csv')
print (df['NUM_BEDROOMS'])
print (df['NUM_BEDROOMS'].isnull())
#结果如下图：
以上例子中我们看到 Pandas 把 n/a 和 NA 当作空数据，na 不是空数据，不符合我们要求，我们可以指定空数据类型：
import pandas as pd
missing_values = ["n/a", "na", "--"]
df = pd.read_csv('property-data.csv', na_values = missing_values)
print (df['NUM_BEDROOMS'])
print (df['NUM_BEDROOMS'].isnull())
#结果如下：
- 实例2——删除包含空数据的行
import pandas as pd
df = pd.read_csv("property-data.csv")
new_df = df.dropna()
print(new_df.to_string())
#结果如下：
注意： 默认情况下，dropna() 方法返回一个新的 DataFrame，不会修改源数据。
如果要修改源数据 DataFrame, 可以使用inplace = True 参数:
import pandas as pd
df = pd.read_csv('property-data.csv')
df.dropna(inplace = True)
print(df.to_string())
#结果如下：
实例3——移除指定列有空值的行
# 移除 ST_NUM 列中字段值为空的行：
import pandas as pd
df = pd.read_csv("property-data.csv")
df.dropna(subset=['ST_NUM'],inplace=True)
print(df.to_string())
#结果如下：
- 实例4——fillna() 方法来替换一些空字段
# 使用 12345 替换空字段：
import pandas as pd
df = pd.read_csv("property-data.csv")
df.fillna('xiaoba',inplace=True)
print(df.to_string())
# 结果如下：
- 实例5——指定替换某一个列的空数据
# 使用 12345 替换 PID 为空数据
import pandas as pd
df = pd.read_csv("property-data.csv")
df['PID'].fillna(12345,inplace=True)
print(df.to_string())
#结果如下：
替换空单元格的常用方法是计算列的均值、中位数值或众数。
Pandas使用 mean()、median() 和 mode() 方法计算列的均值（所有值加起来的平均值）、中位数值（排序后位置在中间的数）和众数（出现频率最高的数）。
- 实例6——使用 mean() 方法计算列的平均值并替换空单元格
import pandas as pd
df = pd.read_csv("property-data.csv")
# 求ST_NUM 列的平均值
x = df["ST_NUM"].mean()
# 将ST_NUM 列中为空的替换为均值
df["ST_NUM"].fillna(x,inplace=True)
print(df.to_string())
# 结果如下：
- 实例7——使用 median() 方法计算列的中位数并替换空单元格
import pandas as pd
df = pd.read_csv("property-data.csv")
# 求ST_NUM 列的中位数
x = df["ST_NUM"].median()
# 将ST_NUM 列中为空的替换为中位数
df["ST_NUM"].fillna(x,inplace=True)
print(df.to_string())
- 实例8——使用 mode() 方法计算列的众数并替换空单元格
import pandas as pd
df = pd.read_csv("property-data.csv")
df
# 求ST_NUM 列的众数
x = df["ST_NUM"].mode()
# 将ST_NUM 列中为空的替换为众数
df["ST_NUM"].fillna(x,inplace=True)
print(df.to_string())
#结果如下：
# 由于众数有两个，故而2个空值的位置各自替换了一个值
8.2 pandas清洗格式错误数据
数据格式错误的单元格会使数据分析变得困难，甚至无法分析。我们可以通过包含空单元格的行，或者将列中的所有单元格转换为相同格式的数据。
import pandas as pd
# 第三个日期格式错误
data = {
"Date":['2020/12/01', '2020/12/02' , '20201226'],
"duration" : [50,40,30]
}
df = pd.DataFrame(data)
df["Date"] = pd.to_datetime(df["Date"]) # 格式化日期
print(df.to_string())
#结果如下：
8.3 pandas 清洗错误数据
遇到错误数据，我们可以对错误的数据进行替换或移除。
- 实例1——替换错误年龄的数据
# 替换错误年龄的数据
import pandas as pd
#年龄数据错误
person = {
"name":["Goole","Runboo","Taobao"],
"age":[50,53,12345]
}
df = pd.DataFrame(person)
# 利用索引修改数据
df.loc[2,'age']=30
print(df.to_string())
# 结果如下
- 实例2——设置条件语句
# 设置条件语句
import pandas as pd
#年龄数据错误
person = {
"name":["Goole","Runboo","Taobao"],
"age":[50,53,12345]
}
df = pd.DataFrame(person)
for x in df.index:
if df.loc[x,'age']>120:
df.loc[x,'age']=120
print(df.to_string())
# 结果如下：
8.5 pandas 清洗重复数据
如果我们要清洗重复数据，可以使用 duplicated() 和 drop_duplicates()方法。
- **实例1——duplicated() **
如果对应的数据是重复的，duplicated() 会返回 True，否则返回 False。
import pandas as pd
person = {
"name": ['Google', 'Runoob', 'Runoob', 'Taobao'],
"age": [50, 40, 40, 23]
}
df = pd.DataFrame(person)
print(df.duplicated())
- 实例2——使用drop_duplicates() 方法删除重复数据
import pandas as pd
person = {
"name": ['Google', 'Runoob', 'Runoob', 'Taobao'],
"age": [50, 40, 40, 23]
}
df = pd.DataFrame(person)
df.drop_duplicates(inplace=True)
df
更多内容待更新~~