python数据处理—pandas相关函数的使用(持续更新）

drop函数的用法

1.DataFrame.drop(self，labels = None，axis = 0，index = None，columns = None，level = None，inplace = False，errors =‘raise’ )

通过指定标签名称和轴，或者直接指定索引或列名称来直接删除行或列。

常用参数含义：

labels : 标签表示索引或列

axis : 指定轴，axis = 0(删除行) axis = 1(删除列)

index : 索引(行) labels, axis=0相当于index=labels

columns : 列 labels, axis=1相当于columns=labels

inplace :布尔类型，默认值为false。采用inplace=True之后，原数组名对应的内存值直接改变
2.drop([ ],axis=0,inplace=True)默认情况下删除某一行，在原来的数据上直接改变

shape函数的用法

pandas是python中处理csv文件常用的一个库
data.shape[0]输出行数
data.shape[1]输出列数
data.shape返回的元组
例子：

import pandas as pd
path =  '西瓜数据集2.1.csv'
data = pd.read_csv(path, header=None)
print(data)
print('data.shape:', data.shape)
print('data.shape[0]:', data.shape[0])
print('data.shape[1]:', data.shape[1])
    

1
2
3
4
5
6
7
8
9

'''    0   1   2   3   4   5   6
0   色泽  根蒂  敲声  纹理  脐部  触感  好瓜
1   青绿  蜷缩  浊响  清晰  凹陷  硬滑   1
2   乌黑  蜷缩  沉闷  清晰  凹陷  硬滑   1
3   乌黑  蜷缩  浊响  清晰  凹陷  硬滑   1
4   青绿  蜷缩  沉闷  清晰  凹陷  硬滑   1
5   浅白  蜷缩  浊响  清晰  凹陷  硬滑   1
6   青绿  稍蜷  浊响  清晰  稍凹  软粘   1
7   乌黑  稍蜷  浊响  稍糊  稍凹  软粘   1
8   乌黑  稍蜷  浊响  清晰  稍凹  硬滑   1
9   乌黑  稍蜷  沉闷  稍糊  稍凹  硬滑   0
10  青绿  硬挺  清脆  清晰  平坦  软粘   0
11  浅白  硬挺  清脆  模糊  平坦  硬滑   0
12  浅白  蜷缩  浊响  模糊  平坦  软粘   0
13  青绿  稍蜷  浊响  稍糊  凹陷  硬滑   0
14  浅白  稍蜷  沉闷  稍糊  凹陷  硬滑   0
15  乌黑  稍蜷  浊响  清晰  稍凹  软粘   0
16  浅白  蜷缩  浊响  模糊  平坦  硬滑   0
17  青绿  蜷缩  沉闷  稍糊  稍凹  硬滑   0
data.shape: (18, 7)
data.shape[0]: 18
data.shape[1]: 7
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

sorted函数的用法

sorted()作为python内置函数之一，该功能就是对序列（列表，元祖，字典，集合，还包括字符串）进行排序。
sorted()函数的基本语法格式如下：
list=sorted(iterable,key=None,reverse=False)
其中，iterable表示指定的序列，key参数可以自定义排序规则，reverse参数指定以升序（False,默认）还是降序(True)进行排序
sorted()函数会返回一个排好序的列表，注意，key参数和reverse参数是可选参数
与sort函数的区别
对数组

a = [3, 2, 4]
sorted(a)
print(a)
print(sorted(a))
1
2
3
4

[3, 2, 4]
[2, 3, 4]

1
2
3

对元组

a = (3, 2, 4)
print(sorted(a))
1
2

[2, 3, 4]
1

对字典

a = {"b":3,"a":2,"c":4}
print(sorted(a))
1
2

['a', 'b', 'c']

1
2

对字符串

a = 'cba'
print(sorted(a))
1
2

['a', 'b', 'c']
1

与sort的区别：
sort是列表类的方法，只对列表有用。不返回值，直接在列表上操作，会改变原对象的值。

sorted(students, key=lambda student : student[2])

key指定的lambda函数功能是去元素student的第三个域（即：student[2]），因此sorted排序时，会以students所有元素的第三个域来进行排序。

1
2
3
4

例如：

res = {'色泽': 0.1081251652653652, '根蒂': 0.14267495956679277, '敲声': 0.14078143361499573, '纹理': 0.3805918973682685, '脐部': 0.28915878284167884, '触感': 0.006046489176565473}
res = sorted(res.items(),key=lambda x:x[1],reverse=True)
print(res)
# reversr=True是降序，将res中的每一个元素当作lambda中的X,此时需要比较的是它们的值
1
2
3
4

[('纹理', 0.3805918973682685), ('脐部', 0.28915878284167884), ('根蒂', 0.14267495956679277), ('敲声', 0.14078143361499573), ('色泽', 0.1081251652653652), ('触感', 0.006046489176565473)]
1

loc与iloc用法区别

loc函数：通过行索引"index"中的具体值来取行数据
iloc函数：通过行号来取行数据
例如：

# 导包
import numpy as np
import pandas as pd
#创建Dataframe
data=pd.DataFrame(np.arange(25).reshape(5,5),index=list('abcde'),columns=list('ABCDE'))
print(data)
# 获取索引为a的行数据
print(data.loc['a'])
print(data.iloc[0])
print(data.iloc[:1])   # 按照切片方式处理，获得第一行数据
# 提取列数据
print(data.loc[:,['A']])
print(data.iloc[:,[0]])
# 提取指定行，列的数据
print(data.loc[['a','b'],['A','B']])
print(data.iloc[[0,1],[0,1]])  # 提取第0，1行，第0，1列的数据
# 提取所有数据
print(data.loc[:,:])
print(data.iloc[:,:])
# 依据某个条件来提取数据所在的行
print(data.loc[data['A']==0])
print(data.loc[(data['A']==0)&(data['B']==1)])
# 提取最后一列数据
print(data.iloc[:,-1])

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

结果：

/Applications/Anaconda-Navigator.app/Contents/MacOS/python /Users/liuqian/PycharmProjects/pythonProject/np.array()_test.py 
    A   B   C   D   E
a   0   1   2   3   4
b   5   6   7   8   9
c  10  11  12  13  14
d  15  16  17  18  19
e  20  21  22  23  24
A    0
B    1
C    2
D    3
E    4
Name: a, dtype: int64
A    0
B    1
C    2
D    3
E    4
Name: a, dtype: int64
   A  B  C  D  E
a  0  1  2  3  4
    A
a   0
b   5
c  10
d  15
e  20
    A
a   0
b   5
c  10
d  15
e  20
   A  B
a  0  1
b  5  6
   A  B
a  0  1
b  5  6
    A   B   C   D   E
a   0   1   2   3   4
b   5   6   7   8   9
c  10  11  12  13  14
d  15  16  17  18  19
e  20  21  22  23  24
    A   B   C   D   E
a   0   1   2   3   4
b   5   6   7   8   9
c  10  11  12  13  14
d  15  16  17  18  19
e  20  21  22  23  24
   A  B  C  D  E
a  0  1  2  3  4
   A  B  C  D  E
a  0  1  2  3  4
a     4
b     9
c    14
d    19
e    24
Name: E, dtype: int64

Process finished with exit code 0

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

value_counts()方法对数组中的重复元素进行统计

例如：

import pandas as pd
import random as rd
list_data = []
for i in range(8):
    list_data.append(rd.randint(0,4))
data = pd.Series(list_data)
print(data)
vc_data = data.value_counts()
print(vc_data)
print(type(vc_data))
1
2
3
4
5
6
7
8
9
10

0    2
1    3
2    4
3    4
4    0
5    1
6    1
7    0
dtype: int64
4    2
0    2
1    2
2    1
3    1
dtype: int64
<class 'pandas.core.series.Series'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16