数据分析与AI(四)pandas处理丢失的数据/傅里叶公式实验/pandas层次化索引检索

绝地灬酷狼 2022-05-22 04:25 209阅读 0赞

# 处理丢失的数据 #

#### mysql中有没有丢失的数据? ####

*  在mysql中null就是列中的丢失数据
 *  在pandas中丢失数据是NaN

# 导入需要用的模块
    import numpy as np
    import pandas as pd
    from pandas import Series, DataFrame

## 在python中有两种 ##

*  np.NaN
 *  None

df = DataFrame({
       'python':[100,101,np.nan,None], 'java':[110,120,119,None]})
    df
    # 结果如下:

![这里写图片描述][70]

# 聚合. sum()求和
    # NaN在运算的时候并没有干扰正常的计算
    df.sum(axis=1)
    
    # NaN虽然没有干扰运算, 但是降低了我们计算的效率
    # 结果如下:
    0    210.0
    1    221.0
    2    119.0
    3      0.0
    dtype: float64

#### 计算速度: int -> float -> object -> nan ####

%timeit np.arange(0,1e6,dtype=np.int).sum()
    # 结果:1.95 ms ± 18.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    %timeit np.arange(0,1e6, dtype=np.float32).sum()
    # 结果:.47 ms ± 213 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
    %timeit np.arange(0,1e6,dtype='object').sum()
    # 结果:75.9 ms ± 6.39 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

python中None的类型本来就是object(NoneType)

numpy中的nan是浮点型

## pandas 中对于空值的操作 ##

*  isnull() \# 判断是否为空
 *  notnull() \# 判断是否不为空
 *  dropna() \# 过滤空值
 *  fillna() \# 填充空值

### isnull ###

cond = df.isnull()
    # 返回bool值, nan为true
    cond
    # 结果如下:

![这里写图片描述][70 1]

### notnull ###

cond = df.notnull()
    cond
    # 结果如下:

![这里写图片描述][70 2]

> 注意: 只有notnull得到的索引值可以通过df\[cond\]来获取相对应的值

### any all ###

cond = df.isnull().any(axis=1)
    cond
    
    # axis = 0 表示对列进行操作, 有一个值为NaN那么返回true
    # 结果如下:
    0    False
    1    False
    2     True
    3     True
    dtype: bool
    # ------------------------------------
    cond = df.isnull().all(axis=1)
    cond
    
    # all条件全部为真,则返回true, 否则返回false
    # 结果如下:
    0    False
    1    False
    2    False
    3     True
    dtype: bool
    # ------------------------------------
    cond1 = df.notnull().all(axis=1)
    cond1
    # 结果如下:
    0     True
    1     True
    2    False
    3    False
    dtype: bool
    # ----------------------------------
    cond1 = df.notnull().any(axis=1)
    cond1
    # 结果如下:
    0     True
    1     True
    2     True
    3    False
    dtype: bool

### dropna() ###

过滤NAN

df
    # 结果如下:

![这里写图片描述][70 3]

# dropna() 将有空值的行直接删除
    # 我们在丛数据分析的时候, 不会删除列(一般连数据都不会删除)
    # 列不可以被删除?   身高一直会变化, 可能数据库这个值就是空值,
    # 行相对于列来说不那么重要

df.dropna()

![这里写图片描述][70 4]

# how的作用是作为保留级别来使用的
    df.dropna(how='all')
    # 结果如下:

![这里写图片描述][70 5]

df1 = DataFrame({
       'python':[np.nan,None,100,101], 'java':[110,120,119,0]})
    df1

![这里写图片描述][70 6]

### fillna() ###

# 通过fillna将值为NAN的数全部填充为0
    df4 = df.fillna(value=0)
    df4
    # 结果如下:

![这里写图片描述][70 7]

# method可选模式:{'backfill', 'bfill', 'pad', 'ffill', None}, default None
    # Method to use for filling holes in reindexed Series
    # pad / ffill: propagate last valid observation forward to next valid
    # backfill / bfill: use NEXT valid observation to fill gap
    # method='ffill' 找前面可用的数据, 向后填充, axis=0的时候拿前一行的值向后填充, axis=1的时候是找前一列的值进行填充
    df4= df.fillna(method='ffill',axis=1)
    df4
    # 结果如下:

![这里写图片描述][70 8]

df5 = DataFrame({
       'python':[100,200,1,201,],'java':[300,100,400,500,],'php':[3,2,None,0]})
    df5
    # 结果如下:

![这里写图片描述][70 9]

# bfill 从后面找第一个值进行填充
    df5.fillna(method='bfill', axis=1)
    
    # 缺点, 如果前后左右任意一方出现无值的情况, 可能会报错

![这里写图片描述][70 10]

# 傅里叶公式运用 #

# 上帝看 : 内在 频率
    # 人看世界: 表象, 时域, 肉眼能识别的
    # 平原, 山丘 联想到平原和山丘的关系就是一种波动
    # 波 原子->波 都是基础的物质
    
    import numpy as np
    
    # fft是傅里叶变换, ifft是反傅里叶变换
    from numpy.fft import fft,ifft
    
    from PIL import Image
    
    import matplotlib.pyplot as plt

# 引入图片
    cat = Image.open('./cat.jpg')
    cat
    # 图片如下:

![这里写图片描述][70 11]

# cat.tobytes()将猫图片对象转化为二进制的文本字符串
    # np.fromstring(cat.tobytes(), np.int8) 从一个二进制文本字符串中初始化成一个int8的数组
    # 注意:数组的数据类型;默认值:浮动。数据必须以二进制输入数据.
    cat_data = np.fromstring(cat.tobytes(), np.int8)
    cat_data
    # 结果如: array([ -25, -70, -125, ..., -68, 95, 62], dtype=int8)

cat_fft = fft(cat_data)
    # 将时域转换成频域 傅里叶的变换
    cat_fft
    # 结果如下:

array([-1569123.               +0.        j,
       -7005918.98362136+12604783.28030717j,
       -2819481.22749804 +8877463.78907501j, ...,
         622731.5619853  -2775345.73593521j,
       -2819481.22749811 -8877463.78907499j,
       -7005918.98362145-12604783.28030712j])

# 求绝对值进行找出柔和的频率
    cond = np.abs(cat_fft) < 1e4 *20
    
    # 将这些柔和的频率去除
    cat_fft[cond] = 0
    
    # 将频域转换成时域
    cat_ifft = ifft(cat_fft)
    cat_ifft
    # 结果如下:

array([-11.32971006+3.75426123e-13j,  39.6547189 -2.63766541e-13j,
       -26.15791263-2.59052660e-13j, ...,  -2.7618658 +5.85713493e-13j,
        49.60338509-7.36865241e-14j, -11.30093432-7.42168361e-13j])

# 将虚数去除
    cat_real = np.real(cat_ifft)
    # 因为是jpg, 不需要浮点数
    cat_result = np.int8(cat_real)
    cat_result
    # 结果:array([-11, 39, -26, ..., -2, 49, -11], dtype=int8)
    --------------------------------------
    cat_lunkuo = Image.frombytes(mode='RGB', size=(730, 456), data=cat_result)
    cat_lunkuo
    # 经过傅里叶运算后的图片如下:

![这里写图片描述][70 12]

# pandas层次化索引 #

# 导入所需要的包
    import numpy as np
    import pandas as pd
    
    from pandas import Series, DataFrame
    import matplotlib.pyplot as plt

## 1. 创建多层行索引 ##

### 1) 隐式构造 ###

最常见的方法是给DataFrame构造函数的index参数传递两个或更多的数组

*  Series也可以创建多层索引

s = Series(np.random.randint(0,150,size=6), 
               index=[['a','a','b','b','c','c'],
                      ['期中','期末','期中','期末','期中','期末']])
    s
    # 结果如下:

![这里写图片描述][70 13]

# 将Series对象s传入DataFrame中, 并命名列名为python
    df = DataFrame(s, columns=['python'])
    df
    # 结果如下:

![这里写图片描述][70 14]

#### DataFrame建立2级列索引 ####

df1 = DataFrame(np.random.randint(0,150,size=(4,6)), 
                    index=list('东南西北'),
                    columns=[['python','python','math','math','En','En'], ['期中','期末','期中','期末','期中','期末']])
    df1

![这里写图片描述][70 15]

### 2) 显示构造pd.MultiIndex ###

*  使用 MultiIndex.from\_tuples()

df3 = DataFrame(np.random.randint(0,150,size=(4,6)), 
                    index=list('东南西北'),
                    columns=pd.MultiIndex.from_tuples([('python','期中'),('python','期末'),
                                                      ('math','期中'),('math','期末'),
                                                      ('En','期中'),('En','期末')]))
    df3
    # 结果如下:

![这里写图片描述][70 16]  
\- 使用product

最简单，推荐使用

df4 = DataFrame(np.random.randint(0,150,size=(4,6)), 
                    index=list('东南西北'),
                    columns=pd.MultiIndex.from_product([['python','math','En'],
                                                      ['期中','期末']]))
    df4
    # 结果如下:

![这里写图片描述][70 17]

============================================

# 练习8： #

1.  创建一个DataFrame，表示出张三李四期中期末各科成绩

============================================

DataFrame(np.random.randint(0,150,size=(4,4)),
                               index=pd.MultiIndex.from_product([['张三','李四'],['期中','期末']]),
                               columns=pd.MultiIndex.from_product([['语文','数学','英语','python']]))
    # 结果如下:

![这里写图片描述][70 18]

## 2. 多层列索引 ##

除了行索引index，列索引columns也能用同样的方法创建多层索引

df4 = DataFrame(np.random.randint(0,150,size=(8,12)),
                    columns=pd.MultiIndex.from_product([['模拟考','正式考'],
                                                      ['数学','语文','英语','物理','化学','生物']]),
                    index=pd.MultiIndex.from_product([['期中','期末'],
                                                      ['雷军','李斌'],
                                                     ['测试一','测试二']]))
    df4

![这里写图片描述][70 19]

## 3. 多层索引对象的索引与切片操作 ##

### 1）Series的操作 ###

【重要】对于Series来说，直接中括号\[\]与使用.loc()完全一样，因此，推荐使用中括号索引和切片。

s
    # 结果如下:

![这里写图片描述][70 20]

#### 切片与索引 ####

# 取多层的外层索引时, 内层索引不可用
    s[['a','b']]

![这里写图片描述][70 21]

# 除此之外还有以下的索引获取值的方式
    s.a.期中
    s['a'][['期中','期末']]['期末']
    s.loc['a'] #注意.loc可以是第一个列表用于取行
    s.iloc[:5] #注意: 通过隐式索引取值都是取到最内层索引的值

### 2）DataFrame的操作 ###

(1) 可以直接使用列名称来进行列索引  
(2) 使用行索引需要用ix()，loc()等函数

【极其重要】推荐使用loc()函数

注意在对行索引的时候，若一级行索引还有多个，对二级行索引会遇到问题！也就是说，无法直接对二级索引进行索引，必须让二级索引变成一级索引后才能对其进行索引！

df4
    # 结果如下:

![这里写图片描述][70 22]

# 索引查询
    df4['模拟考'][['语文','数学']]
    # 结果如下:

![这里写图片描述][70 23]

# 还可以通过以下方式进去获取:
    # loc 和 iloc都是从行还是取 的, 没有loc和iloc是从列开始取的 第二个列表才是行
    df4.loc['期中','雷军','测试一']['模拟考','数学']
    df4.iloc[0]
    
    # 用.来取索引值只能先将列取完才能取行, 同理 先取行必须取完才能取列索引
    df4.模拟考.数学.期中.雷军.测试二
    
    df4['模拟考']

============================================

# 练习9： #

1.  分析比较Series和DataFrame各种索引的方式，熟练掌握.loc()方法
2.  假设张三再一次在期中考试的时候因为特殊原因放弃英语考试，如何实现？

============================================

## 4. 索引的堆（stack） ##

*  `stack()`
 *  `unstack()`

【小技巧】使用stack()的时候，level等于哪一个，哪一个就消失，出现在行里。

df2
    # 查询结果:

![这里写图片描述][70 24]

# stack的作用是将<列>索引变成了<行>最内层的索引
    # level 代表的是层级, 默认为-1 代表为最内层
    df2.stack(level=1)

![这里写图片描述][70 25]

【小技巧】使用unstack()的时候，level等于哪一个，哪一个就消失，出现在列里。

# unstack 是将<行>索引编程列的最<内>层索引 level默认-1, 也就是最内层的行索引
    df4.unstack()

![这里写图片描述][70 26]

# 如果想把所有的<行>索引都转成<列>索引, 怎么办?
    # 给level一个list , 可以解决
    df4.unstack(level=[0,1,2])

模拟考  数学  期中  李斌  测试一    130
                 测试二    119
             雷军  测试一     51
                 测试二    108
         期末  李斌  测试一     88
                 测试二    127
             雷军  测试一     74
                 测试二    141
     语文  期中  李斌  测试一     95
                 测试二    119
             雷军  测试一      5
                 测试二    129
         期末  李斌  测试一     71
                 测试二     63
             雷军  测试一     36
                 测试二     66
     英语  期中  李斌  测试一    108
                 测试二     27
             雷军  测试一     53
                 测试二     67
         期末  李斌  测试一     75
                 测试二     37
             雷军  测试一     19
                 测试二     30
     物理  期中  李斌  测试一     29
                 测试二     16
             雷军  测试一    126
                 测试二     94
         期末  李斌  测试一    119
                 测试二     24
                       ... 
    正式考  英语  期中  雷军  测试一     64
                     测试二     92
             期末  李斌  测试一     87
                     测试二     47
                 雷军  测试一    118
                     测试二     47
         物理  期中  李斌  测试一    138
                     测试二     67
                 雷军  测试一    124
                     测试二     86
             期末  李斌  测试一     37
                     测试二     98
                 雷军  测试一     27
                     测试二    104
         化学  期中  李斌  测试一     11
                     测试二    112
                 雷军  测试一     14
                     测试二     38
             期末  李斌  测试一    114
                     测试二     61
                 雷军  测试一    106
                     测试二      4
         生物  期中  李斌  测试一    108
                     测试二     97
                 雷军  测试一    101
                     测试二    146
             期末  李斌  测试一     49
                     测试二    149
                 雷军  测试一     18
                     测试二    109

# Length: 96, dtype: int32 #

# 练习10： #

1.  使用unstack()将sf4变为两行，分别为期中期末
2.  使用unstack()将ddd变为四行，分别为四个科目

============================================

# 1.
    df4.unstack(level=[1,2])
    
    # 2.
    df4.unstack()  #结果没有展示
    # 结果:

![这里写图片描述][70 27]

## 5. 聚合操作 ##

【注意】

*  需要指定axis
 *  【小技巧】和unstack()相反，聚合的时候，axis等于哪一个，哪一个就保留。  
    所谓的聚合操作：平均数，方差，最大值，最小值……

df2
    # 结果如下:

![这里写图片描述][70 28]

df2.sum(axis=0)
    # 结果如下:

![这里写图片描述][70 29]

df2.std(axis=1) # 求列方向的方差
    df2.max(axis=1) # 求列方向的最大值
    df2.max(axis=0) # 求行方向的最大值
    
    df2.sum(axis=1)
    # 结果如下:

![这里写图片描述][70 30]

============================================

# 练习11： #

1.  计算各个科目期中期末平均成绩
2.  计算各科目张三李四的最高分

============================================

# 1.计算各个科目期中期末平均成绩
    df4.mean(axis=0, level=(0))
    # 结果:

![这里写图片描述][70 31]

# 2.计算各科目张三李四的最高分
    df4.max(level=(1))
    # 结果

![这里写图片描述][70 32]

[70]: /images/20220522/3914bdeeec4346b29852cd071de7fb69.png
[70 1]: /images/20220522/5853ab694737442e8ca878ec38da060d.png
[70 2]: /images/20220522/1fa3513b673649bdb26d9a5428dc1c2b.png
[70 3]: /images/20220522/76feb7f5061c464a884d92c0787df76f.png
[70 4]: /images/20220522/075f489dd778460fae7ff1d30fb267f1.png
[70 5]: /images/20220522/c3bfde3559f44397a7de33cbb89ce609.png
[70 6]: /images/20220522/e7af32cb44284fdc90d2e182666128eb.png
[70 7]: /images/20220522/13e913d6094246688b05a2ba0db89792.png
[70 8]: /images/20220522/7a7663949e17475abcbedd905e7cb39e.png
[70 9]: /images/20220522/068c42dcf22e4f378057d277d6d0261c.png
[70 10]: /images/20220522/a65a4abc5cff47d7b3eb5db3d71e0320.png
[70 11]: /images/20220522/575f150e3c034a59bafed292070ab2d4.png
[70 12]: /images/20220522/a11a5160914446c7bdb8512e7c2a2a2e.png
[70 13]: /images/20220522/c422fd95fc1e40489aef276c141357e2.png
[70 14]: /images/20220522/3b8eda3f14e040f2b0e9417a4bc93923.png
[70 15]: /images/20220522/44762795660448a995214b04adf3051b.png
[70 16]: /images/20220522/e0d7f24ca06a4f459be125ea7affccb9.png
[70 17]: /images/20220522/901112f0f31b4209992c3f2a7991c6ec.png
[70 18]: /images/20220522/b9b693283b694121acbd99ec1d6f8fe0.png
[70 19]: /images/20220522/a94f4f8cbeec46c7b75f171b4d15e99d.png
[70 20]: /images/20220522/6df550c71b8c400b9e635cf301b9122d.png
[70 21]: /images/20220522/e6b753a3b89d423f8130b73c4b2cfd20.png
[70 22]: /images/20220522/06207a064cb041b5af9330c6ac5fb113.png
[70 23]: /images/20220522/de93dea1509a4530b1fefc22faaf6ba1.png
[70 24]: /images/20220522/c6051b0290234510a6cbcf9b526f0322.png
[70 25]: /images/20220522/a10c6acbfaab40839d46a27831ee227b.png
[70 26]: /images/20220522/3da45b21afba459fa785bd4f05747029.png
[70 27]: /images/20220522/4dbbb6a2817b4bdcbc3374fffb57ab28.png
[70 28]: /images/20220522/128f32e50c7e47d28c85833d847f0e15.png
[70 29]: /images/20220522/d08c600e74b14a1196c53e614d7c5d2d.png
[70 30]: /images/20220522/0f0b9e7a99ae4925832aa0d8f11bf8f3.png
[70 31]: /images/20220522/902c10dd3d1d4e78905270f3f5ce993c.png
[70 32]: /images/20220522/5f85c89d79164186a7e0632ecb3745f3.png