python数据处理随笔总结_python数据处理的总结

可能写的有些杂乱，毕竟是遇到哪个就写了哪个，可以直接看目录或ctrl f搜索，找自己想要的哪个函数。当然也在时刻补充，遇到新的就会往这里添加。

csv文件读取

pandas中，常用的载入函数是read_csv。除此之外还有read_excel和read_table，table可以读取txt。

import pandas as pd
file=pd.read_csv("77.csv",encoding='utf-8')#encoding选择编码方式
file
1
2
3

提取文件中的某个（某些）特征

trname=file['triggername']
trname
#提取某些
#Count=data[['confirmedCount','curedCount']]
1
2
3
4

head展示前几个数据（tail后几个）

一般是前五个，现在是设定的前8个

查看某个数据总数及类型

data.info()
1

data.gender.value_counts()
1

删除某一行或者列

import pandas as pd
#创建一个dataframe变量
df = pd.DataFrame(np.arange(16).reshape(4,4),
                  index = list('1234'),
                 columns = list('ABCD'))
print(df)
#删除列
df.drop(['A'], axis = 1,inplace=True)
print(df)
#删除行
df.drop(['1'], axis = 0, inplace = True)
print(df)
1
2
3
4
5
6
7
8
9
10
11
12

查看所有数据的总数及类型

data.info()
1

.get_dummies 函数自动变换所有具有对象类型（比如字符串）的列或所有分类的列

data.head()查看数据的前几行

Dataframe是pandas的一种数据类型

有关DDataFrame的详细知识 https://www.jianshu.com/p/8024ceef4fe2

demo_df = pd.DataFrame({'Integer Feature': [0, 1, 2, 1],'Categorical Feature': ['socks', 'fox', 'socks', 'box']}) 

display(demo_df)
1
2
3

将两个数据拼接在一起

np.hstack([X, X_binned])
### 快速浏览数据
有总数，数据类型
```python
file.head(8)
1
2
3
4
5

hpbl80NTc1NTMzMg==,size_16,color_FFFFFF,t_70)

文件描述describe

只展示是数字数据的特征，总数，均值等等

file.describe()#

1
2

查看独一无二的数据

查看某一列空值：df.isnull()

file['sysEname'].unique()
1

查看列名称：

file.columns
1

数据清洗

drop_duplicates函数通过subset参数选择以哪个列为去重基准。keep参数则是保留方式，first是保留第一个，删除后余重复值，last还是删除前面，保留最后一个。duplicated函数功能类似，但它返回的是布尔值。
原来是1543 每个特征只保留一个，就剩下了9

file.drop_duplicates(subset="triggername",keep='first')
1

将两个数据拼接在一起

np.hstack([X, X_binned])
1

查看数据的列（行是row）

list(data.columns)
1

提取两个特征之间的所有特征

这是提取了age和’occupation_ Transport-moving之间的数据

features = data_dummies.loc[:, 'age':'occupation_ Transport-moving']
1

转换数据类型

如age是int型，age.astype(str) 转换成了字符型

将数字数据转化为矩阵

# neHotEncoder和ColumnTransformer:使用scikit-learn的分类变量
from sklearn.preprocessing import OneHotEncoder

#将上面的表格转化成矩阵形式
ohe = OneHotEncoder(sparse=False)
print(ohe.fit_transform(demo_df))
1
2
3
4
5
6

python中的获得索引、和值得方法：enumerate

groups=[0,1,2,3,4]
label=['weather','temperature','humidity','wind_direction','wind_speed']
list(enumerate(label))

[(0, 'weather'),
 (1, 'temperature'),
 (2, 'humidity'),
 (3, 'wind_direction'),
 (4, 'wind_speed')]
1
2
3
4
5
6
7
8
9
'
运行
运行

将连续数据归一化，其他分类特征热编码处理

scikit-learn在0.20.0版本中新增了一个 sklearn.compose.ColumnTransformer
类，通过这个类我们可以对输入的特征分别做不同的预处理，并且最终的结果还在一个特征空间里面。

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler
#讲age hours这种连续特征标准化（归一化），其他分类特征热编码
ct = ColumnTransformer(
    [("scaling", StandardScaler(), ['age', 'hours-per-week']),
     ("onehot", OneHotEncoder(sparse=False), ['workclass', 'education', 'gender', 'occupation'])])
1
2
3
4
5
6

json文件转换成字典

json.load

json_dict=json.load(open("xxx.json"))
type(json_dict)

dict
1
2
3
4

字典 转换为 字符串

json.dumps(json_dict)
1

将数据写入json文件中

dump

with open("xxx.json","w") as f:
    json.dump(new_dict,f)
1
2

pandas的shift（）函数

直接看代码就可以理解

df = pd.DataFrame(np.arange(16).reshape(4,4),columns=['AA','BB','CC','DD'],index =['a','b','c','d'])

df
Out[14]: 
   AA  BB  CC  DD
a   0   1   2   3
b   4   5   6   7
c   8   9  10  11
d  12  13  14  15
#当period为正时，默认是axis = 0轴的设定，向下移动
df.shift(2)
Out[15]: 
    AA   BB   CC   DD
a  NaN  NaN  NaN  NaN
b  NaN  NaN  NaN  NaN
c  0.0  1.0  2.0  3.0
d  4.0  5.0  6.0  7.0
#当axis=1，沿水平方向进行移动，正数向右移，负数向左移
df.shift(2,axis = 1)
Out[16]: 
   AA  BB    CC    DD
a NaN NaN   0.0   1.0
b NaN NaN   4.0   5.0
c NaN NaN   8.0   9.0
d NaN NaN  12.0  13.0
#当period为负时，默认是axis = 0轴的设定，向上移动
df.shift(-1)
Out[17]: 
     AA    BB    CC    DD
a   4.0   5.0   6.0   7.0
b   8.0   9.0  10.0  11.0
c  12.0  13.0  14.0  15.0
d   NaN   NaN   NaN   NaN
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

freq： DateOffset, timedelta, or time rule string，可选参数，默认值为None，只适用于时间序列，如果这个参数存在，那么会按照参数值移动时间索引，而数据值没有发生变化。

df = pd.DataFrame(np.arange(16).reshape(4,4),columns=['AA','BB','CC','DD'],index =pd.date_range('6/1/2012','6/4/2012'))

df
Out[38]: 
            AA  BB  CC  DD
2012-06-01   0   1   2   3
2012-06-02   4   5   6   7
2012-06-03   8   9  10  11
2012-06-04  12  13  14  15

df.shift(freq=datetime.timedelta(1))
Out[39]: 
            AA  BB  CC  DD
2012-06-02   0   1   2   3
2012-06-03   4   5   6   7
2012-06-04   8   9  10  11
2012-06-05  12  13  14  15

df.shift(freq=datetime.timedelta(-2))
Out[40]: 
            AA  BB  CC  DD
2012-05-30   0   1   2   3
2012-05-31   4   5   6   7
2012-06-01   8   9  10  11
2012-06-02  12  13  14  15
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

numpy.concatenate((a1,a2,…), axis=0)

能够一次完成多个数组的拼接。其中a1,a2,…是数组类型的参数

>>> a=np.array([1,2,3])
>>> b=np.array([11,22,33])
>>> c=np.array([44,55,66])
>>> np.concatenate((a,b,c),axis=0)  # 默认情况下，axis=0可以不写
array([ 1,  2,  3, 11, 22, 33, 44, 55, 66]) #对于一维数组拼接，axis的值不影响最后的结果
1
2
3
4
5

>>> a=np.array([[1,2,3],[4,5,6]])
>>> b=np.array([[11,21,31],[7,8,9]])
>>> np.concatenate((a,b),axis=0)
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [11, 21, 31],
       [ 7,  8,  9]])
1
2
3
4
5
6
7

>>> np.concatenate((a,b),axis=1)  #axis=1表示对应行的数组进行拼接
array([[ 1,  2,  3, 11, 21, 31],
       [ 4,  5,  6,  7,  8,  9]])
1
2
3

inverse_transform()将标准化后的数据转换为原始数据。

 X=scaler.inverse_transform(X[, copy])

将标准化后的数据转换为原始数据。

X=pca.inverse_transform(newX)

将降维后的数据转换成原始数据
1
2
3
4
5
6
7

pd.merge实现数据合并

pandas.merge(left, right, 
             how='inner', on=None, 
             left_on=None, right_on=None, 
             left_index=False, right_index=False, 
             sort=False, suffixes=('_x', '_y'), 
             copy=True, indicator=False, 
             validate=None)
1
2
3
4
5
6
7

left: 拼接的左侧DataFrame对象
right: 拼接的右侧DataFrame对象
on: 要加入的列或索引级别名称。 必须在左侧和右侧DataFrame对象中找到。 如果未传递且left_index和right_index为False，则DataFrame中的列的交集将被推断为连接键。
left_on:左侧DataFrame中的列或索引级别用作键。 可以是列名，索引级名称，也可以是长度等于DataFrame长度的数组。
right_on: 左侧DataFrame中的列或索引级别用作键。 可以是列名，索引级名称，也可以是长度等于DataFrame长度的数组。
left_index: 如果为True，则使用左侧DataFrame中的索引（行标签）作为其连接键。 对于具有MultiIndex（分层）的DataFrame，级别数必须与右侧DataFrame中的连接键数相匹配。
right_index: 与left_index功能相似。
how: One of ‘left’, ‘right’, ‘outer’, ‘inner’. 默认inner。inner是取交集，outer取并集。比如left：[‘A’,‘B’,‘C’];right[’'A,‘C’,‘D’]；inner取交集的话，left中出现的A会和right中出现的买一个A进行匹配拼接，如果没有是B，在right中没有匹配到，则会丢失。'outer’取并集，出现的A会进行一一匹配，没有同时出现的会将缺失的部分添加缺失值。
sort: 按字典顺序通过连接键对结果DataFrame进行排序。 默认为True，设置为False将在很多情况下显着提高性能。
suffixes: 用于重叠列的字符串后缀元组。 默认为（‘x’，’ y’）。
copy: 始终从传递的DataFrame对象复制数据（默认为True），即使不需要重建索引也是如此。
indicator:将一列添加到名为_merge的输出DataFrame，其中包含有关每行源的信息。 _merge是分类类型，并且对于其合并键仅出现在“左”DataFrame中的观察值，取得值为left_only，对于其合并键仅出现在“右”DataFrame中的观察值为right_only，并且如果在两者中都找到观察点的合并键，则为left_only。

import pandas as pd

left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                       'A': ['A0', 'A1', 'A2', 'A3'],
                       'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                        'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']})
result = pd.merge(left, right, on='key')

# on参数传递的key作为连接键
result
Out[4]: 
    A   B key   C   D
0  A0  B0  K0  C0  D0
1  A1  B1  K1  C1  D1
2  A2  B2  K2  C2  D2
3  A3  B3  K3  C3  D3

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