python对.pkl文件的操作

1.pkl文件

pkl文件是python里面保存文件的一种格式，如果直接打开会显示一堆序列化的东西（二进制文件）。
常用于保存神经网络训练的模型或者各种需要存储的数据。

1. 保存神经网络训练模型举例（使用pytorch进行保存）
   保存整个网络：torch.save(net, ‘net.pkl’)
   保存网络的状态信息：torch.save(net.state_dict(), ‘net_params.pkl’)
   提取神经网络的方法：
   torch.load(‘net.pkl’)
2. 存储数据举例

import pandas as pd
import numpy as np

df = pd.DataFrame(np.arange(20).reshape(4,5))
df.to_pickle('foo.pkl')
data=pd.read_pickle('foo.pkl')
print(data)
1
2
3
4
5
6
7

输出为：

    0   1   2   3   4
0   0   1   2   3   4
1   5   6   7   8   9
2  10  11  12  13  14
3  15  16  17  18  19
1
2
3
4
5

2.pickle库对文件进行写入，读取操作

1. 写入pkl文件

import pickle
#wb是覆盖写，如果需要追加，则为‘ab'
f = open('data.pkl','wb')
#待写入数据
datas = {'name':'Bruce','age':25,'high':175}
#写入
data= pickle.dump(datas,f,-1)
#关闭文件
f.close()
1
2
3
4
5
6
7
8
9

2. 读取.pkl文件

f = open('data.pkl','rb')
#使用load的方法将数据从pkl文件中读取出来
pickle.load(f)
#关闭文件
f.close()
1
2
3
4
5

3.pandas库对文件进行写入，读取操作

1. 写入.pkl文件：

使用DataFrame的to_pickle就可以生成pickle文件，因此如果需要存储其他类型的数据将其转化为DataFrame即可存取，例如将dict类型数据保存在.pkl文件中

import pandas as pd
import numpy as np
df = pd.DataFrame(np.arange(20).reshape(4,5))
#使用DataFrame的to_pickle就可以生成pickle文件
df.to_pickle('data.pkl')
#通过字典创建数据
dic={'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]}
df2 = pd.DataFrame(dic,index=["a","b","c"])
df2.to_pickle('data2.pkl')

#字典的键和值将转换为DataFrame的两列，其列名如选项列中所给
stu = {
     'xiaoming':2,
     'xiaohong':3,
    'xiaoqiang':7,}

print(pd.DataFrame(list(stu.items()),columns=['name', 'age']))
'''
输出结果为：
         name   age
0     xiaoming   2
1     xiaohong   3
2     xiaoqiang  7
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2. 读取.pkl文件：

data=pd.read_pickle('data.pkl')
data2=pd.read_pickle('data2.pkl')
print('data:\n',data)
print('data2:\n',data2)
1
2
3
4

输出为

data:
     0   1   2   3   4
0   0   1   2   3   4
1   5   6   7   8   9
2  10  11  12  13  14
3  15  16  17  18  19
data2:
    A  B  C
a  1  4  7
b  2  5  8
c  3  6  9

1
2
3
4
5
6
7
8
9
10
11
12

4.pandas库常用函数及其作用

1. loc和iloc（截取特定数据）
   https://blog.csdn.net/qq1483661204/article/details/77587881
   https://blog.csdn.net/htbeker/article/details/80332360
   除了通过标签和索引进行选择某一行（列）或者区域的数据，还可以完成符合条件的数据选取。

1.根据指定的索引列表查找

import pandas as pd
dic={'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]}
df = pd.DataFrame(dic,index=["a","b","c"])
print('data:\n',df)
ids=[0,2]
data=df.iloc[ids]
print('choose\n',data)

1
2
3
4
5
6
7
8

data:
    A  B  C
a  1  4  7
b  2  5  8
c  3  6  9
choose
    A  B  C
a  1  4  7
c  3  6  9
1
2
3
4
5
6
7
8
9

2.根据指定的**行列标签（不是索引）**进行查找

import pandas as pd
dic={'A':[1,2,3],'B':[4,5,6],'C':[7,5,7]}
df = pd.DataFrame(dic)
print('data:\n',df)
data=df.loc[0,'A']
print(data)
dic1={'A':[1,2,3],'B':[4,5,6],'C':[7,5,7]}
df1 = pd.DataFrame(dic1,index=['a','b','c'])
print('data:\n',df1)
data1=df1.loc['a','A']
print(data1)
1
2
3
4
5
6
7
8
9
10
11

data:
    A  B  C
0  1  4  7
1  2  5  5
2  3  6  7
1
data:
    A  B  C
a  1  4  7
b  2  5  5
c  3  6  7
1
1
2
3
4
5
6
7
8
9
10
11
12

3.根据判断条件查找

dic1={'A':[1,2,3],'B':[4,5,6],'C':[7,5,7]}
df1 = pd.DataFrame(dic1,index=['a','b','c'])
print('data:\n',df1)
print('-------------------')
data1=df1.loc[df1['B']==4,'C']
print(data1)
1
2
3
4
5
6

data:
    A  B  C
a  1  4  7
b  2  5  5
c  3  6  7
-------------------
a    7
Name: C, dtype: int64
1
2
3
4
5
6
7
8

2. .unique（去除重复元素，行列写法不同）

import pandas as pd
dic={'A':[1,2,3],'B':[4,5,6],'C':[7,5,7]}
df = pd.DataFrame(dic,index=["a","b","c"])
print('data:\n',df)

print('\n.unique:(列)\n',df['C'].unique())
#.loc默认逗号分隔，逗号前是行，逗号后是列
print('\n.unique:(行)\n',df.loc['b'].unique())
print('\n.unique:(列)\n',df.loc[:,'C'].unique())
1
2
3
4
5
6
7
8
9

data:
    A  B  C
a  1  4  7
b  2  5  5
c  3  6  7

.unique:(列)
 [7 5]

.unique:(行)
 [2 5]

.unique:(列)
 [7 5]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4. set_index和reset_index（设置索引）
   https://blog.csdn.net/jingyi130705008/article/details/78162758
5. drop（删除数据）
   https://www.cnblogs.com/wodexk/p/10316674.html
6. .merge（DataFrame对象拼接）
   https://blog.csdn.net/brucewong0516/article/details/82707492
7. Series（常用数据结构）
   pandas两个主要的数据结构：Series和DataFrame。
   Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成。

from pandas import Series,DataFrame
data = Series([9,23,3,56])
print(data)
1
2
3

输出索引在左，数值在右。在没有指定具体的索引时，则自动创建一个0~N-1的整数型索引

0     9
1    23
2     3
3    56
dtype: int64
1
2
3
4
5

可以通过Series的values和index属性获取数组的值和索引

print('data.values',data.values)
print('data.index',data.index)
1
2

data.values [ 9 23  3 56]
data.index RangeIndex(start=0, stop=4, step=1)
1
2

pandas的isnull和notnul或者实例方法data.isnull()可用于检测缺失数据：

import pandas as pd
from pandas import Series,DataFrame
dict={'a':1000,
      'b':900,
      'c':800}
data=Series(dict)
index=['a','b','d']
#根据字典和给出的索引创建Series
data2=Series(dict,index)
print('-'*20)
print('data\n',data)
print('-'*20)
print('data2\n',data2)
print('-'*20)
print('isnull\n',pd.isnull(data2))
print('-'*20)
print('notnull\n',pd.notnull(data2))
print('-'*20)
print('data2.isnull\n',data2.isnull())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

--------------------
data
 a    1000
b     900
c     800
dtype: int64
--------------------
data2
 a    1000.0
b     900.0
d       NaN
dtype: float64
--------------------
isnull
 a    False
b    False
d     True
dtype: bool
--------------------
notnull
 a     True
b     True
d    False
dtype: bool
--------------------
data2.isnull
 a    False
b    False
d     True
dtype: bool
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

参考链接：
https://zhuanlan.zhihu.com/p/32190141