【Python】pandas & numpy

rejudge

已于 2024-01-16 14:47:24 修改

阅读量1.1k

点赞数

分类专栏： Python 文章标签： numpy pandas python

于 2022-11-16 16:50:07 首次发布

本文链接：https://blog.csdn.net/qq_45249685/article/details/127888437

版权

Python 专栏收录该内容

43 篇文章 3 订阅

订阅专栏

pandas & numpy 数据处理

pandas
numpy

pandas

1. 读加载索引 pd.read_csv(’ ', index_col= , header=/names=[,] )

读数据加载行索引

# 把首列作为行索引
pd.read_csv('./train/train.csv', index_col=0)

读数据加载列索引

pd.read_csv('./train/train.csv', header=0) # 首行作为列名
pd.read_csv('./train/train.csv', header=[0, 1]) #0,1行作为列名

读数据指定列名，用于csv文件没有列名，直接读会将第一行读为列名

pd.read_csv('./diff_mean_scaler_std.csv',names=['fea', 'std'])

2. 存加载索引 df.to_csv(’ ', index= , header= )

# index=False 不保存列索引
# header=False 不保存行索引
data.to_csv('./node1.csv', index=False, header=False)

3. 合并数据 pd.merge() .concat()

【Python】pandas merge,concat合并数据集

4. 添加新列

df['列名'] = [1,2,3,4] # 默认添加到最后列

df.insert(loc=0, column='列名', value=[1,2,3,4])

pd.concat([df1, df2])

5. 分组聚合 df.groupby([‘’,‘’]).

5.1. df.groupby().mean()

# 按tenure列的取值分组，计算每组平均值
# .sum() .count()
df.groupby('tenure').mean()
'''
tenure	SeniorCitizen	MonthlyCharges
1	    0.0	            29.850
2	    1.0	            62.275
3	    0.5	            65.035
4	    1.5	            59.335
'''

5.2. df.groupby().agg()

'''
df.agg('mean') 计算列均值
df.agg('mean', axis=1) 计算行均值
df.agg({'行名/列名1': ['mean', 'min', 'max']
       ,'行名/列名2'：['函数名1', '函数名2', '函数名3']}) 

df.reset_index() 更新索引，'tenure'由索引变为特征列
'''
aggs = {'SeniorCitizen': ['mean', 'min', 'max'], 
		'MonthlyCharges': ['mean', 'min', 'max']}
df.groupby('tenure').agg(aggs).reset_index()
'''
	tenure	SeniorCitizen	  MonthlyCharges
			mean min max	mean   min   max
0	1		0.0	 0	 0	   29.850 29.85	29.85
1	2		1.0	 0	 2	   62.275 53.85	70.70
2	3		0.5	 0	 1	   65.035 56.95	73.12
3	4		1.5	 0	 3	   59.335 42.30	76.37
'''

proteins_npx_ft = proteins.groupby('visit_id').agg(NPX_min=('NPX','min'), NPX_max=('NPX','max')).reset_index()
proteins_npx_ft.head()
'''
visit_id	    NPX_min	   NPX_max	    NPX_mean	NPX_std
0	10053_0	    2497.84	269126000.0	2.856580e+06	2.131630e+07
1	10053_12	5800.87	270030000.0	2.728871e+06	2.092162e+07
2	10053_18	1334.11	278835000.0	2.509967e+06	1.969453e+07
3	10138_12	2520.24	365582000.0	3.002583e+06	2.516170e+07
4	10138_24	1436.94	396894000.0	3.068891e+06	2.716806e+07
'''

5.3. df.groupby().transrform()

'''
按照class列分组，每组有学生的score，
计算score的平均值，赋值给新列
'''
df['df_mean'] = df.groupby('class')['score'].transform('mean')
'''
  class name score df_mean
0   1    a     100   450
1   2    b     9      8
2   1    c     800   450
3   2    d     7      8
'''

5.4. df.groupby().ffill/dfill() & df.fillna(method=‘bfill/fill’)

axis = 0/1
df.ffill(axis = 0) 用上一行值填充，第一行缺失值无法填充
df.ffill(axis = 1) 用前一列值填充，第一列缺失值无法填充
df.groupby().ffill()
df.groupby('name1')['name2'].ffill() 按name1列取值进行分组，每组对name2列取值进行填充计算
返回分组前按原索引顺序排列的一组值，可直接在原数据基础上替换原列
df.bfill()
df.bfill() 用后一行/列填充
df.fillna()

df.fillna(method='bfill/fill', axis=0/1)

5.5. df.groupby().cumcount()

'''
   A              A
0  a         0    0
1  a         1    1
2  a         2    2
3  b   >>>   3    0
4  b         4    1
5  a         5    3
按A的取值分组，
对a分组内的'a'进行索引标记，索引分别记为0,1,2,3；
对b分组内的'b'进行索引标记，索引记为0,1；
a,b的索引值替代A列的a,b 。
返回分组前按原索引顺序排列的一组值，可直接在原数据基础上替换原列
'''
 df.groupby('A').cumcount()

5.6. df.groupby().shift()

df = pd.DataFrame({"a":[1,1,2,2,3,3],"b":[11,22,33,44,55,66]})
df.groupby('a').shift(1)
'''
按a列的取值分组   b >>> 11,22 | 33,44 | 55,66
组内的值后移一位  b >>> NaN,11 | NaN,33 | NaN,55 
可以紧接着用ffill/bfill填充NaN
'''

6. 拆分数据（宽数据↔长数据）

6.1. df.melt() 列名(指定列)>>>值

'''
https://vimsky.com/examples/usage/python-pandas-melt.html
pandas.melt(df, id_vars=None, value_vars=None, 
            var_name=None, value_name='value', col_level=None)
    id_vars 保留的列
    value_vars=['a','b'] ab两列变为一列，该列取值有'a''b'两种;后面加一列，取值对应原ab属性的值
    var_name='' 上述合并列的名字
    value_name='' 上述所加列的名字
'''
clinical_melt = clinical.melt(id_vars=['id','month']
							 ,value_vars=['updrs_1','updrs_2']
							 ,var_name=['updrs']
							 ,value_name='rating')
clinical_melt

id month updrs_1 updrs_2      id month updrs    rating
1  0     2       3            1  0     updrs_1  2
2  1     2       1      >>>   1  0     updrs_2  3
                              2  1     updrs_1  2
                              2  1     updrs_2  1

6.2. df.stack() 列名(除索引列外所有列)>>>值

'''
.stack() 索引不变，所有列名变为新的一列的取值，紧跟一列取值对应列名原取值
    month updrs                  level_1  level_2   
0     2       3              0 | month    2
1     2       1      >>>       | updrs    3
                             --------------------
                             1 | month    2
                               | updrs    1
                             --------------------
.reset_index()
         old_idx   level_1  level_2   
       0    0    | month    2
 >>>   1    0    | updrs    3
       2    1    | month    2
       3    1    | updrs    1
'''

df_trans = table1.stack().reset_index()
#df_trans.columns=["cfips","variable","Value"]
df_trans['level_1'].unique()
df_trans['level_1'].drop_duplicates() # 可查看原有列名

6.2. df.pivot() 值(指定列的取值)>>>列名

df = pd.DataFrame({'class':[1,1,2]
             ,'name':['Tom', 'John', 'Cindy']
             ,'age':[12, 22, 34]})
             
'''             
   class  name  age      name  Cindy  John  Tom
0  1      Tom   12       class
1  1      John  22  >>>  1     NaN    22.0  12.0
2  2      Cindy 34       2     34.0   NaN   NaN
'''
df.pivot(index=['class'], columns='name', values='age')

'''          
   class  name  age      name  class  Cindy  John  Tom
0  1      Tom   12       0     1      NaN    22.0  12.0
1  1      John  22  >>>  1     2      34.0   NaN   NaN
2  2      Cindy 34       
'''
df.pivot(index=['class'], columns='name', values='age').reset_index()

7. 遍历每行/列

7.1 df.apply() 遍历每行并操作 / (lambda使用方法)

df
'''
  cfips	variable	Value
0	0	pct_bb_2017	76.6
1	0	pct_bb_2018	78.9
2	0	pct_bb_2019	80.6

  ...  -3 -2 -1
pct_bb_20  1  7
'''

df.apply(lambda x:x["variable"][-4:],axis=1) # >>> 2017
df.apply(lambda x:x["variable"][:-5],axis=1) # >>> pct_bb

7.2 df.iterrows() for循环遍历每列

'''
遍历DataFrame每一行，返回索引和内容
'''
for idx, value in df.iterrows():
	...

7.3 df.iteritems() for循环遍历每列

'''
遍历DataFrame每一列，返回列名和内容
'''
for colname, col in df.iteritems():
	print('特征名', colname)
	print('一列的值', col)
	...

8. 重复行操作

8.1 查找重复行 df.duplicates()

'''
data.duplicated() 返回布尔型，True为重复值位置
data.duplicated().sum() 求重复值个数
data[data.duplicated()==True] 打印重复

data.drop_duplicates(inplace=True) 删除重复值，inplace=True表示直接在源数据上进行操作
data.reset_index() 重置索引
'''
tcc.duplicated().sum() # 说明无重复行
'''
    0
'''

8.2 删除重复行 df.drop_duplicates()

'''
subset
	a,b列的取值, 判断是否重复的
keep 
	'first' 保留第一个出现的重复行，删除其他重复行
	'last' 保留最后一个出现的重复行，删除其他重复行
	 False 删除所有重复行
inplace
	True 直接在原数据上删除重复项
	False(默认) 删除重复项后返回一个副本
'''
df.drop_duplicates(subset=['a','b'],keep='first',inplace=True)

9. 字符 ->数字 pd/Series.factorize()

'''
pd/Series.factorize() 
	factorize 分解
	字符型变量分解为数字 'A','B' >>> 0,1
'''
nums, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'])
nums [0,0,1,2,0]
uniques ['b','a','c']
'''
sort=True
'''
pd.factorize(['b', 'b', 'a', 'c', 'b'], sort=Ture) >>> [1,1,0,2,1], ['a','b','c']
'''
有None值编码为-1
'''

10. 临行/列差值填充 df.diff()

'''
   a  b  c               a  b  c
0  1  1  1            0  NaN NaN NaN
1  2  1  4            1  1  0  3
2  3  2  9            2  1  1  5
3  4  3  16    >>>    3  1  1  7
4  5  5  25           4  1  2  9
5  6  8  36           5  1  3  11
'''
df.diff() # 默认第i行与i-1行做差，首行填充为NaN

'''
   a  b  c               a  b  c
0  1  1  1            0  NaN NaN NaN
1  2  1  4            1  NaN NaN NaN
2  3  2  9            2  NaN NaN NaN
3  4  3  16    >>>    3  3  2  15
4  5  5  25           4  3  4  21
5  6  8  36           5  3  6  27
'''
df.diff(periods=3) # 第i, i+1, i+2行分别于i-1, i-2, i-3行做差，前三行填充为NaN

df.diff(axis= ) # 对列操作

11. 窗口函数

11.1 滑动窗口 pd.rolling()

Pandas滑动窗口函数rolling()的使用方法（入门够用）

'''
center       结果放在哪，默认最右侧
min_periods  窗口最少包含的值数量，默认None
on           DataFrame的那一列进行滑动窗口
axis         默认为0，即对列进行计算
closed       定义区间的开闭，支持int类型的window。对于offset类型默认是左开右闭的即默认为right。
             可以根据情况指定为left、both等。
'''

window
窗口大小

'''
   0             0
0  1          0  NaN
1  2          1  NaN
2  3          2  1.0
3  4          3  2.0
4  5   >>>    4  3.0
5  6          5  4.0
6  7          6  5.0
7  8          7  6.0
8  9          8  7.0
'''
df.rolling(window=3).min()  >>> [1,2,3][2,3,4]...[7,8,9] ->1,2,3,4,5,6,7

min_periods
最小包含值的个数，防止了NaN出现

'''
当window=3时，索引0和1将填充NaN，
设置min_periods=1，窗口在[0,1,2]时，0处最小取[1]，1处取[1,2]
   0             0
0  1          0  NaN
1  2          1  1.0
2  3          2  2.0
3  4          3  3.0
4  5   >>>    4  4.0
5  6          5  5.0
6  7          6  6.0
7  8          7  7.0
8  9          8  NaN
'''
df.rolling(window=3, min_periods=1).min()

'''
当window=3时，索引0和1将填充NaN，
设置min_periods=2，窗口在[0,1,2]时，0处最小不能取[1](小于最小取值个数2)填充NaN,1处取[1,2]
   0               0
0  1          0  NaN
1  2          1  1.0
2  3          2  1.0
3  4          3  2.0
4  5   >>>    4  3.0
5  6          5  4.0
6  7          6  5.0
7  8          7  6.0
8  9          8  7.0
'''
df.rolling(window=3, min_periods=2).min()

center
将窗口内的取值放到中间位置

'''
   0             0
0  1          0  NaN
1  2          1  1.0
2  3          2  2.0
3  4          3  3.0
4  5   >>>    4  4.0
5  6          5  5.0
6  7          6  6.0
7  8          7  7.0
8  9          8  NaN
'''
a.rolling(window=3, center=True, min_periods=1).min()

11.2 扩展窗口 pd.expanding()

rolling()： window参数固定窗口大小，进行滑动计算
expanding()： min_periods参数设置最小的观测值数量，不固定窗口大小，实现累计计算，即不断扩展；
当rolling()函数的参数window=len(df)时，实现的效果与expanding()函数是一样的

'''
   A  B                  A    B
0  9  1             0  NaN  NaN | | | |
1  3  2             1  NaN  NaN | | | |
2  2  3   >>>       2  2.0  1.0 - | | |
3  1  4             3  1.0  1.0 --| | |
4  4  5             4  1.0  1.0 ----| |
5  0  6             5  0.0  1.0 ----- |
'''
df.expanding(min_periods=3).min()
df.rolling(window=6, min_periods=3).min()

'''
   A  B                  A    B
0  9  1             0  NaN  NaN
1  3  2             1  3.0  1.0
2  2  3   >>>       2  2.0  1.0
3  1  4             3  1.0  1.0
4  4  5             4  1.0  1.0
5  0  6             5  0.0  1.0
'''
df.expanding(min_periods=2).min()

12. 选取指定特征指定取值的行

12.1 将该列转为索引，再按索引选出行 df.set_index(‘col_name’).loc[]

将该列转为索引，再按索引选出行
.iloc[55] 会重新按0开始索引，指选出第55行
.loc[55] 选出索引是55的行
当索引值和顺序相同时，两者一样

feature_vals = [2, 3, 4]
df.set_index('列名').loc[feature_vals]
# 注意使用 .loc[]

12.2 多重筛选 df[条件1 &| 条件2]

'''
筛选出只有'2023-04'和'2023-05' 的行
& 按位与运算
'''
df[(df.pt > '2023-03') & (df.pt < '2023-06')]

12.2 apply(lambda)选出True，再筛选

proteins[proteins.apply(lambda x: True if x['patient_id'] in train_patient_ids else False, axis=1)]

13. query查找 df.query()

https://segmentfault.com/a/1190000042221256

df[df['age'] == 12]
df.query('age == 12')

df.query(f'Peptide in @peptide_candidates')
visit_id = 123
df.query(f'visit_id=="{visit_id}"')

14. .loc[] \ .iloc[]

- 可用列名索引
df.loc[:, 'text']

- 必须用数字索引定位
df.iloc[:, 2]

15. 列重命名 df.rename(columns={n1: n2})

df.rename(columns={'ID':'id','code':'编码'})

16. 查看筛选指定数据类型的列 df.dtypes

str_col = [*test_set.dtypes[test_set.dtypes == 'object'].index]
str_col
'''
['source_IP_address', 'Destination_IP_address'] string类型
'''

17. 统计列的每个取值的个数 value_counts()


df['col_name'].value_counts()

sum(df['col_name'] == value)

18. 按某列排序 .sort_values(‘col_name’, ascending=)

# false 降序排序
df.sort_values('col', ascending=False)

numpy

1. 合并数据

1.1 np.c_[,]

# 两矩阵左右相连，要求行数相等 类似pd.merge()
np.c_[np.array(data1), np.array(data2)]

1.2 np.r_[, , , ]

# 两矩阵上下相连，要求列数相等 类似pd.concat()
np.r_[np.array(data1), np.array(data2), np.array(data3)]

1.3 np.concatenate((data1, data2), axis=)

待拼接数据的axis维度值必须相同

import numpy as np

a = [[1, 1], 
     [2, 2], 
     [3, 3], 
     [4, 4]]
b = [['a', 'a'], 
     ['b', 'b'], 
     ['c', 'c'], 
     ['d', 'd']]

np.concatenate((a, b), axis=0)
'''
array([['1', '1'],
       ['2', '2'],
       ['3', '3'],
       ['4', '4'],
       ['a', 'a'],
       ['b', 'b'],
       ['c', 'c'],
       ['d', 'd']], dtype='<U21')
'''

np.concatenate((a, b), axis=1)
'''
array([['1', '1', 'a', 'a'],
       ['2', '2', 'b', 'b'],
       ['3', '3', 'c', 'c'],
       ['4', '4', 'd', 'd']], dtype='<U21')
'''

2. np.where()

np.where(condition,x,y) condition 成立，返回x，否则返回y；
np.where(condition) condition成立，返回每个符合condition条件的元素的坐标,形式是元组(idx1, idx2,…)。

3. 空值 nan

3.1. 创建 np.float32/64(‘nan’)

np.float32('nan')
np.float64('nan')

3.2. 判断 df[‘’]/math.isna()

df['列名'].isna()
math.isnan()

3.3. 查找 df.isnull()

'''
只表示没有None或Nan，并不排除可能存在别的值表示缺失的情况
'''
df.isnull().sum() # 返回各列nan情况
'''
    customerID          0
    gender              0
    SeniorCitizen       0
    Partner             0
    Dependents          0
    tenure              0
    PhoneService        0
    MultipleLines       0
    InternetService     0
    OnlineSecurity      0
    OnlineBackup        0
    DeviceProtection    0
    TechSupport         0
    StreamingTV         0
    StreamingMovies     0
    Contract            0
    PaperlessBilling    0
    PaymentMethod       0
    MonthlyCharges      0
    TotalCharges        0
    Churn               0
    dtype: int64
'''

4. 限制取值范围

4.1. 边界修剪 np.clip()

'''
clip 修剪
最小值小于a_min时变为a_min
最大值大于a_max时变为a_max
a_min/max = None 下/上边界不设限
'''
numpy.clip(a, a_min, a_max, out=None)

4.2. 选择范围内的元素 np.where()

返回 (满足条件元素的1维坐标, 满足条件元素的2维坐标, ...)，坐标为array格式。

a =[0.5, 1.15, 1.5, 1.6]
x = np.array(a)
np.where(x>1)
'''
(array([1, 2, 3], dtype=int64),)
'''

x = np.arange(24).reshape(2,3,4)
x
'''
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
'''
np.where(x>5)
'''
(array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int64), 
 array([1, 1, 2, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), 
 array([2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
'''

4.3. 数的舍入

4.3.1. 4舍6入5凑偶 np.around()/round()

5舍6入得整数，小数点后最后一位是5舍为与其值最接近的偶数值

X = [1.4, 1.5, 1.6, 2.4, 2.5, 2.6]
np.around(X), np.round(X)
'''
array([1., 2., 2., 2., 2., 3.]), 
array([1., 2., 2., 2., 2., 3.])
'''

考虑小数位 decimals=

X = [1.44, 1.55, 1.66, 2.44, 2.55, 2.66]
np.around(X, decimals=0), np.round(X, decimals=0)
'''
array([1., 2., 2., 2., 3., 3.]), 
array([1., 2., 2., 2., 3., 3.])
'''
np.round(X, decimals=1)
'''
array([1.4, 1.6, 1.7, 2.4, 2.6, 2.7])
'''

4.3.2. 向下取整 np.floor()

a =[0.5, 1.15, 1.5, 1.6]
np.floor(a)
'''
array([0., 1., 1., 1.])
'''

4.3.3. 向上取整 np.ceil()

a =[0.5, 1.15, 1.5, 1.6]
np.ceil(a)
'''
array([1., 2., 2., 2.])
'''

5. 拼接数据

数据

X = np.arange(0, 24).reshape(4, 6)
X
'''
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])
'''
Y = np.arange(24, 48).reshape(4, 6)
Y
'''
array([[24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35],
       [36, 37, 38, 39, 40, 41],
       [42, 43, 44, 45, 46, 47]])
'''

5.1 np.stack()

'''
[ X,
  Y ]
'''
np.stack([X, Y])
'''
array([[[ 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]]])
'''

'''
[ [X0, Y0],
  [X1, Y1],
  ...
  [Xn, Yn] ]
'''
np.stack([X, Y] , axis=1)
'''
array([[[ 0,  1,  2,  3,  4,  5],
        [24, 25, 26, 27, 28, 29]],

       [[ 6,  7,  8,  9, 10, 11],
        [30, 31, 32, 33, 34, 35]],

       [[12, 13, 14, 15, 16, 17],
        [36, 37, 38, 39, 40, 41]],

       [[18, 19, 20, 21, 22, 23],
        [42, 43, 44, 45, 46, 47]]])
'''

5.2 np.row_stack()

'''
[ X0,
  X1,
  ...
  Xn,
  Y0,
  Y1,
  ...
  Yn ]
'''

np.row_stack([X, Y] )
'''
array([[ 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]])
'''

5.3 np.column_stack()

'''
X0与Y0之间没有“,” 表示元素直接拼接
[ [X0 Y0],
  [X1 Y1],
  ...
  [Xn Yn] ]
'''
np.column_stack([X, Y] )
'''
array([[ 0,  1,  2,  3,  4,  5, 24, 25, 26, 27, 28, 29],
       [ 6,  7,  8,  9, 10, 11, 30, 31, 32, 33, 34, 35],
       [12, 13, 14, 15, 16, 17, 36, 37, 38, 39, 40, 41],
       [18, 19, 20, 21, 22, 23, 42, 43, 44, 45, 46, 47]])
'''

6. 保存读取模型/list np.save() /load()

import numpy as np

np.save('/kaggle/working/model_updrs_1.npy', clf)
model = np.load('/kaggle/input/save-model/odel_updrs_1.npy', allow_pickle='TRUE').item()

x = [1, 2, 3, 4]
np.save('./x.npy', x)
np.load('./x.npy')

7. 数组维度拉平(n, ) array.ravel()

import numpy as np
n = np.array([[1, 2, 3],
       	      [3, 4, 5],
              [4, 5, 6]])
n.ravel()
'''
array([1, 2, 3, 3, 4, 5, 4, 5, 6])
'''

8. 取中位数 np.median()/nanmedian()

np.median() 不忽略nan
np.nanmedian() 忽略nan

X = np.array([[1, np.nan, 2],
              [3, 4, 5]])
'''
array([[ 1., nan,  2.],
       [ 3.,  4.,  5.]])
'''
np.median(X)
'''
nan
'''
np.nanmedian(X)
'''
3.0
'''

9. 取平均值 array.mean(axis= )

data = np.array([[1, 2],
                 [3, 4],
                 [5, 6]])
                 
data.mean(axis=0), data.mean(axis=1)
'''
(array([3., 4.]), array([1.5, 3.5, 5.5]))
'''

10. 对数变换

10.1 np.log()

负数不可计算，取nan
0取负无穷
(0, 1)取负数

np.log([-1, 0, 0.5, 1, 1.5, 2])
'''
array([nan, -inf, -0.69314718, 0., 0.40546511, 0.69314718])
'''

10.2 np.log1p()

负数不可计算，取nan
0取0
(0, 1)取正数
np.log1p 函数可以处理小于 1 的数据，而不会返回负无穷大

np.log1p([-1, 0, 0.5, 1, 1.5, 2])
'''
array([-inf, 0. , 0.40546511, 0.69314718, 0.91629073, 1.09861229])
'''

10.3 用于特征处理

对标签进行 log 变换是一种常用的预处理方法，其目的是将数据中的大量小值和少量大值的差异缩小，使得模型更加关注于小的值。
当标签的取值范围非常广泛，或者存在明显的长尾分布时，这种变换可以将原始的标签值 y 变换成 log(y)，从而使得在训练模型时帮助降低数据的偏差和方差。

11. 升/降序排列元素的对应索引排列 array.argsort()

'''
idx 0 1 2 3
val 2 3 1 0
输出按val升序排列的对应索引排列 >>> [3, 2, 0, 1]
'''
X = np.array([2,3,1,0])
X.argsort()
'''
array([3, 2, 0, 1])
'''

X.argsort()[::-1]
'''
array([1, 0, 2, 3])
'''

12. 返回最大元素索引 array.argmax()

l
'''
array([[2, 1],
       [3, 2]]
'''
# 行方向选最大值
l.argmax(1)
'''
array([0, 0], dtype=int64)
'''
# 列方向选最大值
l.argmax(0)
'''
array([1, 1], dtype=int64)
'''

13. ubyte文件读取

'''
t10k-images-idx3-ubyte 数据是3维的
t10k-labels-idx1-ubyte 数据是1维的

文件的前4个字节包含数据信息，以idx3为例
分别为 magic_number, num_images, num_rows, num_cols
1. magic_number 文件类型 png、jpg...
2. num_images 图片数量
3. (num_rows, num_cols) 图片维度
最终数据维度为 (num_images, num_rows, num_cols)
'''

13.1 读取数据

import numpy as np

def read_idx3_ubyte(file_path):
	with open(file_path, 'rb) as f:
		# 读取魔数
		magic_number = int.from_bytes(f.read(4), byteorder='big')
		# 读取数据维度
		nums_images = int.from_bytes(f.read(4), byteorder='big')
		num_rows = int.from_bytes(f.read(4), byteorder='big')
		num_cols = int.from_bytes(f.read(4), byteorder='big')

		# 读取数据
		image_data = np.fromfile(f, dtype=np.unit8)
		image_data = image_data.reshape(num_images, num_rows, num_cols)
	
	return image_data
file_path = 't10k-images-idx3-ubyte'
images = read_idx3_ubyte(file_path)

13.2 读取标签

import numpy as np


def read_idx1_ubyte(file_path):
	with open(file_path, 'rb) as f:
		# 读取魔数
		magic_number = int.from_bytes(f.read(4), byteorder='big')
		# 读取数据维度
		nums_labels = int.from_bytes(f.read(4), byteorder='big')

		# 读取数据
		label_data = np.fromfile(f, dtype=np.unit8)
		
	return label_data
file_path = 't10k-labels-idx1-ubyte'
labels = read_idx3_ubyte(file_path)

14. 随机 np.random

14.1 随机生成指定范围的整数array np.random.randint

# 整数范围
np.random.randint(low=0, high=2, size=(2,2,2,2))

14.2 随机指定维度array np.random.rand

np.random.rand(2, 2, 2)
'''
[[[0.7795889  0.34465106]
  [0.7255785  0.55465951]]

 [[0.18290402 0.06534046]
  [0.49993853 0.04746666]]]
'''