Pandas进阶及傅立叶了解

pandas层次化索引

进行练习前,还是先把库引入jupyter notebook

import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt

1. 创建多层行索引

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

  • Series也可以创建多层索引
In[]:
s = Series(np.random.randint(0,150,size=6),index=[['a','a','b','b','c','c'],['期中','期末','期中','期末','期中','期末']])
s
Out[]:
a  期中    59
   期末    43
b  期中    28
   期末    99
c  期中    92
   期末    58
dtype: int32
In[]:
df = DataFrame(s,columns=['python'])
df
Out[]:
    python
a   期中  59
期末  43
b   期中  28
期末  99
c   期中  92
期末  58

DataFrame建立2级列索引


```python
In[]:
df1 = DataFrame(np.random.randint(0,150,size=(4,6)),
               index = list('东南西北'),
               columns=[['python','python','math','math','En','En'],['期中','期末','期中','期末','期中','期末']])
df1
Out[]:
python  math    En
期中  期末  期中  期末  期中  期末
东   45  48  74  142 81  2227  61  7   146 42  129
西   25  36  99  14  143 629   107 146 33  31  0




<div class="se-preview-section-delimiter"></div>

显示构造pd.MultiIndex

  • 使用数组
    “`
# 显示构造pd.MultiIndex

- **使用数组**
```python
In[]:
df2 = DataFrame(np.random.randint(0,150,size=(4,6)),
               index = list('东南西北'),
               columns=[['python','python','math','math','En','En'],['期中','期末','期中','期末','期中','期末']])
df2
Out[]:
python  math    En
期中  期末  期中  期末  期中  期末
东   139 55  22  14  77  959   90  131 114 78  131
西   26  86  27  117 142 9153  1   128 67  12  63




<div class="se-preview-section-delimiter"></div>
  • 使用tuple
    python
- **使用tuple**
```python
In[]:
df3 = DataFrame(np.random.randint(0,150,size=(4,6)),
               index = list('东南西北'),
               columns =pd.MultiIndex.from_tuples([('python','期中'),('python','期末'),
                                                  ('math','期中'),('math','期末'),
                                                  ('En','期中'),('En','期末')]))
df3
Out[]:
python  math    En
期中  期末  期中  期末  期中  期末
东   32  72  2   102 136 128124 0   145 83  69  50
西   120 128 84  129 130 134143 70  76  112 124 75




<div class="se-preview-section-delimiter"></div>
  • 使用product
    最简单,推荐使用

多层列索引

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

- **使用product**
     最简单,推荐使用
# 多层列索引
除了行索引index,列索引columns也能用同样的方法创建多层索引
```python
In[]:
df4 = DataFrame(np.random.randint(0,150,size=(8,12)),
               columns = pd.MultiIndex.from_product([['模拟考','正式考'],
                                                   ['数学','语文','英语','物理','化学','生物']]),
               index = pd.MultiIndex.from_product([['期中','期末'],
                                                   ['雷军','李斌'],
                                                  ['测试一','测试二']]))
df4
Out[]:
模拟考 正式考
数学  语文  英语  物理  化学  生物  数学  语文  英语  物理  化学  生物
期中  雷军  测试一 61  90  97  6   118 127 143 35  79  4   90  54
测试二 96  128 146 107 148 62  68  7   104 103 78  2
李斌  测试一 67  14  115 81  33  76  123 26  45  100 138 91
测试二 32  85  149 47  15  33  8   131 138 45  95  91
期末  雷军  测试一 65  83  100 17  63  115 74  8   116 121 107 42
测试二 125 93  146 25  99  115 134 5   13  72  119 119
李斌  测试一 4   144 114 79  22  47  44  111 116 124 11  54
测试二 16  109 1   104 62  128 104 1   16  19  97  38




<div class="se-preview-section-delimiter"></div>

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

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

#3.多层索引对象的索引与切片操作
1)Series的操作
【重要】对于Series来说,直接中括号[]与使用.loc()完全一样,因此,推荐使用中括号索引和切片。
(1) 索引
```python
In[]: s
Out[]:
a  期中    59
   期末    43
b  期中    28
   期末    99
c  期中    92
   期末    58
dtype: int32




<div class="se-preview-section-delimiter"></div>

python

```python
In[]:
s['a','期中']
Out[]:
59
In[]:
#取多层的外层索引时,内层索引不可用
s[['a','b']]
Out[]:
a  期中    59
   期末    43
b  期中    28
   期末    99
dtype: int32
In[]:
s.a.期中
Out[]:
59
In[]:
s['a'][['期中','期末']]['期中']
Out[]:
59

以上便是三种不同的方法取期中的值

In[]:
s.loc['a']
Out[]:
期中    59
期末    43
dtype: int32
In[]:
#iloc计算的是最内层索引
s.iloc[:5]
Out[]:
a  期中    59
   期末    43
b  期中    28
   期末    99
c  期中    92
dtype: int32

2)DataFrame的操作

(1) 可以直接使用列名称来进行列索引
(2) 使用行索引需要用ix(),loc()等函数
【极其重要】推荐使用loc()函数
注意在对行索引的时候,若一级行索引还有多个,对二级行索引会遇到问题!也就是说,无法直接对二级索引进行索引,必须让二级索引变成一级索引后才能对其进行索引!

In[]:
df4
Out[]:
                        模拟考 正式考
            数学  语文  英语  物理  化学  生物  数学  语文  英语  物理  化学  生物
期中  雷军  测试一 61  90  97  6   118 127 143 35  79  4   90  54
测试二 96  128 146 107 148 62  68  7   104 103 78  2
李斌  测试一 67  14  115 81  33  76  123 26  45  100 138 91
测试二 32  85  149 47  15  33  8   131 138 45  95  91
期末  雷军  测试一 65  83  100 17  63  115 74  8   116 121 107 42
测试二 125 93  146 25  99  115 134 5   13  72  119 119
李斌  测试一 4   144 114 79  22  47  44  111 116 124 11  54
测试二 16  109 1   104 62  128 104 1   16  19  97  38
In[]:
df4['模拟考'][['语文','数学']]
Out[]:
            语文  数学
期中  雷军  测试一 90  61
测试二 128 96
李斌  测试一 14  67
测试二 85  32
期末  雷军  测试一 83  65
测试二 93  125
李斌  测试一 144 4
测试二 109 16
In[]:
df4.loc['期中','雷军','测试一']['模拟考','数学']
Out[]:
        模拟考  数学     61
     语文     90
     英语     97
     物理      6
     化学    118
     生物    127
正式考  数学    143
     语文     35
     英语     79
     物理      4
     化学     90
     生物     54
Name: (期中, 雷军, 测试一), dtype: int32
In[]:
#iloc是只取最内层的索引的
df4.iloc[0]
Out[]:
模拟考  数学     61
     语文     90
     英语     97
     物理      6
     化学    118
     生物    127
正式考  数学    143
     语文     35
     英语     79
     物理      4
     化学     90
     生物     54
Name: (期中, 雷军, 测试一), dtype: int32
In[]:
#列. 索引从列开始取,必须一层层取,取完列索引,才可以取行索引
#先取行索引同理
df4.模拟考.数学.期中.雷军.测试一
Out[]:
     61
In[]:
a=df4['正式考']
a
Out[]:
                数学  语文  英语  物理  化学  生物
期中  雷军  测试一 143 35  79  4   90  54
测试二 68  7   104 103 78  2
李斌  测试一 123 26  45  100 138 91
测试二 8   131 138 45  95  91
期末  雷军  测试一 74  8   116 121 107 42
测试二 134 5   13  72  119 119
李斌  测试一 44  111 116 124 11  54
测试二 104 1   16  19  97  38

索引的堆(stack)

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

5. 聚合操作

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

傅立叶

import numpy as np
from PIL import Image 
# fft是傅里叶变换,反傅里叶变换
from numpy.fft import fft, ifft
import matplotlib.pyplot as plt
# 上帝看世界:看内在, 频率, 波
# 人看世界:看表象,时域,肉眼能识别的
# 肉眼能看:平原, 山丘, 联想到平原和山丘的关系就是一种波动
# 肉眼看不见:波 原子->都是基础的物质
cat = plt.imread('./cat.jpeg')
# 浮点数不利于计算
cat.tobytes()
# 这是一个二进制的数据
# 转化2进制
# uint8 255
cat_data = np.fromstring(cat.tobytes(),np.int8)
cat_data
Out[]:
    array([ -25,  -70, -125, ...,  -68,   95,   62], dtype=int8)
cat_fft = fft(cat_data)
# 将时域转化成频域 --傅里叶的变换
cat_fft
Out[]:
array([-1569123.               +0.j        ,
       -7005918.98362136+12604783.28030717j,
       -2819481.22749804 +8877463.78907501j, ...,
         622731.5619853  -2775345.73593521j,
       -2819481.22749811 -8877463.789075j  ,
       -7005918.98362145-12604783.28030712j])
# 最好求绝对值
cond=np.abs(cat_fft) < 1e5
# 将这些柔和的频率去除
cat_fft[cond] = 0
# 将频域转化成时域
cat_ifft = ifft(cat_fft)
cat_ifft
Out[]:
    array([-31.23561646+8.36461177e-13j,  39.44677252-4.54933103e-13j,
       -31.5575318 -3.42927554e-13j, ..., -17.97882673+8.64438000e-13j,
        56.94689652-3.02996114e-13j,  -4.95576222-8.46613566e-13j])
# 必须将虚数去除
cat_real = np.real(cat_ifft)
cat_real
Out[]:
array([-31.23561646,  39.44677252, -31.5575318 , ..., -17.97882673,
        56.94689652,  -4.95576222])
#jpg, 不需要浮点数
cat_result = np.int8(cat_real)
cat_result
Out[]:
array([-31,  39, -31, ..., -17,  56,  -4], dtype=int8)
luokuo = Image.frombytes(mode='RGB', size=(730,456), data=cat_result)
luokuo

最后,输出的图片就变成如下所示:
这里写图片描述

阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页