Pandas与傅里叶公式应用_dataframe 傅里叶

Pandas与傅里叶公式应用

# mysql中有没有丢失的数据
# 在mysql中null就是列中的丢失数据
# 在pandas中的丢失数据是NaN
1
2
3

import numpy as np
import pandas as pd
from pandas import Series, DataFrame
1
2
3

在python中有两种

• np.NaN
• None

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

# 聚合， sum()求和
# NaN在运算的时候并没有干扰正常的计算
df.sum()

# 虽然没有干扰运算，但是降低了计算的效率
1
2
3
4
5

• 输出

  java 349.0
  python 201.0
  dtype: float64

df.sum(axis=1)
1

• 输出

  0 210.0
  1 221.0
  2 119.0
  3 0.0
  dtype: float64

# int->float->object->nan
1

%timeit np.random.randint(0, 10, size=10).sum()
1

• 输出
  9.05 µs ± 85.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit np.random.random(10).sum()
1

• 输出
  6.83 µs ± 76.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit np.arange(0, 1e6, dtype=np.float32).sum()
1

• 输出
  2.76 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit np.arange(0, 1e6, dtype='object').sum()
1

• 输出
  74.5 ms ± 513 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

#python中None的类型本身就是object
#numpy中nan是float
1
2

pandas中对于空值的操作

- innull()
- notnull()
- dropna() # 过滤空值
- fillna() # 填充空值
1
2
3
4

isnull

df
1

cond = df.isnull()
# 返回Bool值， nan为true
cond
1
2
3

df[cond]
1

notnull

cond = df.notnull()
cond
1
2

df[cond]
1

any all

cond = df.isnull().any()
cond
# axis = 0 对列进行操作， 有一个值为NaN那么返回true
1
2
3

• 输出

  java True
  python True
  dtype: bool

cond = df.isnull().any(axis=1)
cond
1
2

• 输出

  0 False
  1 False
  2 True
  3 True
  dtype: bool

df[cond]
1

cond = df.isnull().all(axis=1)
cond

# all条件全部为真， 则返回true
1
2
3
4

• 输出

  0 False
  1 False
  2 False
  3 True
  dtype: bool

df[cond]
1

cond1 = df.notnull().all(axis=1)
cond1
1
2

• 输出

  0 True
  1 True
  2 False
  3 False
  dtype: bool

df[cond1]
1

cond1 = df.notnull().any(axis=1)
cond1
1
2

• 输出

  0 True
  1 True
  2 True
  3 False
  dtype: bool

df[cond1]
1

dropna()
过滤NaN

df
1

df.dropna()

# dropna将有空值的行直接删除了
# 我们在做数据分析的时候不会删除列（一般连数据都不会删除）
# 列不可以被删除,?, 身高一直会变化，可能数据中这个值就是空值，有的人有身高值
# 行相对于列来说不那么重要
1
2
3
4
5
6

# how的作用是作为保留级别来使用的
df.dropna(how='all')
1
2

.add()

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

df.loc[3]['java'] = 0
df
1
2

df2 = df.add(df1)
df2
1
2

df2 = df.add(df1, fill_value=0)
df2
1
2

fillna() NaN过滤

df4 = df.fillna(value=0)
df4
1
2

df1 = df1.fillna(value=0)
df1
1
2

df4 + df1
1

# method='ffill' 找前面合法的数据，向后填充，axis=0拿前一行的值向后填充，
# axis=1 拿前一列的值来填充
df4 = df.fillna(method='ffill', axis=0)
df4
1
2
3
4

df5 = DataFrame({'python': [100, 200, 101, 201], 'java':[300, 100, 400, 500], 'php':[3, 2, None, 0]})
df5

1
2
3

df5.fillna(method='bfill', axis=1)

# 缺点，如果前后左右任意一方出现无值的情况，可能会报错
1
2
3

# 电费
# 2017

我们要清缴 12次
1     2     3     4     5     6     7     8      9     
120   120   100   50    60    65                 100


# 2018 你的数据丢失了
6   70

# 拉格朗日 插值法
1
2
3
4
5
6
7
8
9
10
11
12

傅里叶

import numpy as np
# fft 是傅里叶变换 
# ifft 是反傅里叶变换

from numpy.fft import fft, ifft
from PIL import Image

import matplotlib.pyplot as plt
1
2
3
4
5
6
7
8

# 上帝：内在 频率 波
# 人看世界，表象， 时域， 肉眼能识别的 音乐

# 平原 山丘 联想到平原和山丘的关系就是一种波动

# 波 原子-> 波 都是基础的物质
1
2
3
4
5
6

# 引入图片
cat = Image.open('./cat.jpg')
1
2

cat
1

# 转换二进制
# uint8 255

cat_data = np.fromstring(cat.tobytes(), np.int8)
1
2
3
4

C:\Users\Administrator\Anaconda3\lib\site-packages\ipykernel_launcher.py:4: DeprecationWarning: The binary mode of fromstring is deprecated, as it behaves surprisingly on unicode inputs. Use frombuffer instead
  after removing the cwd from sys.path.
1
2

cat_data
1

• 输出

  array([ -25, -70, -125, …, -68, 95, 62], dtype=int8)

cat_fft = fft(cat_data)

# 将时域转换成频域 傅里叶的变换
1
2
3

cat_fft
1

• 输出

  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) < 1e5
# 将这些柔和的频率去除
cat_fft[cond] = 0
1
2
3
4

# 将频域转换成时域
cat_ifft = ifft(cat_fft)
cat_ifft
1
2
3

• 输出

  array([-31.23561646+8.34668854e-13j, 39.44677252-4.52878489e-13j,
  -31.5575318 -3.39153475e-13j, …, -17.97882673+8.73942419e-13j,
  56.94689652-2.73174518e-13j, -4.95576222-8.42775705e-13j])

# 必须将虚数部分去除

cat_real = np.real(cat_ifft)
cat_real
1
2
3
4

• 输出

  array([-31.23561646, 39.44677252, -31.5575318 , …, -17.97882673,
  56.94689652, -4.95576222])

# jpg, 不需要浮点数
cat_result = np.int8(cat_real)
cat_result
1
2
3

• 输出

  array([-31, 39, -31, …, -17, 56, -4], dtype=int8)

cat.mode
1

• 输出

  ‘RGB’

cat.size
1

• 输出
  (730, 456)

c = Image.frombytes(mode='RGB', size=(730, 456), data=cat_result)
c
1
2

pandas层次化索引

import numpy as np
import pandas as pd
from pandas import Series, DataFrame
import matplotlib.pyplot as plt
1
2
3
4

1. 创建多层行索引

1) 隐式构造

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

• Series也可以创建多层索引

s = Series(np.random.randint(0, 150, size=10), index = list('qwertyuiop'))
s
1
2

• 输出

  q 50
  w 45
  e 14
  r 36
  t 126
  y 63
  u 122
  i 133
  o 48
  p 102
  dtype: int32

s = Series(np.random.randint(0, 150, size=6), index = [['a', 'a', 'b', 'b', 'c', 'c'],['期中', '期末','期中', '期末','期中', '期末',]])
s
1
2

• 输出

  a 期中 113
  期末 105
  b 期中 27
  期末 65
  c 期中 111
  期末 11
  dtype: int32

df = DataFrame(s, columns=['python'])
df
1
2

DataFrame建立2级列索引

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

2) 显示构造pd.MultiIndex

• 使用数组

df2 = DataFrame(np.random.randint(0,150, size=(4, 6)),
               index = list('东南西北'),
               columns=[['python', 'python', 'math', 'math', 'en', 'en'], ['期中', '期末','期中', '期末','期中', '期末']])
d2
1
2
3
4

• 使用tuple

df3 = DataFrame(np.random.randint(0,150, size=(4, 6)),
               index = list('东南西北'),
               columns=pd.MultiIndex.from_tuples([('python', '期中'),('python', '期末'),('math', '期中'),('math', '期末'),('en', '期中'),('en', '期末')]))
df3
1
2
3
4

• 使用product

  最简单，推荐使用

df4 = DataFrame(np.random.randint(0,150, size=(4, 6)),
               index = list('东南西北'),
               columns=pd.MultiIndex.from_product([{'python', 'math', 'en'}, ['期中', '期末']]))
df4
1
2
3
4

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

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

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

2. 多层列索引

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

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

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

1）Series的操作

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

(1) 索引

s
1

• 输出

  a 期中 113
  期末 105
  b 期中 27
  期末 65
  c 期中 111
  期末 11
  dtype: int32

s['a', '期中']
1

• 输出

  113

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

• 输出

  a 期中 113
  期末 105
  b 期中 27
  期末 65
  dtype: int32

s.a.期中
1

• 输出

  113

s['a'][['期中','期末']]
1

• 输出

  期中 113
  期末 105
  dtype: int32

# iloc计算的是最内层的索引
s.iloc[0]
1
2

• 输出

  113

(2) 切片

#iloc计算的事最内层索引
s.iloc[:5]
1
2

• 输出

  a 期中 113
  期末 105
  b 期中 27
  期末 65
  c 期中 111
  dtype: int32

2）DataFrame的操作

(1) 可以直接使用列名称来进行列索引

(2) 使用行索引需要用ix()，loc()等函数

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

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

df5
1

df5['模拟考'][['语文', '数学']]
1

df5.loc['期中', '雷军', '测试一']['模拟考', '数学']
1

• 输出

  64

# iloc是只取最内层索引的
df5.iloc[0]
1
2

• 输出

  模拟考 数学 64
  语文 47
  英语 145
  物理 31
  化学 31
  生物 16
  正式考 数学 37
  语文 132
  英语 134
  物理 123
  化学 60
  生物 50
  Name: (期中, 雷军, 测试一), dtype: int32

df5.loc['期中', '雷军', '测试一']
1

• 输出

  模拟考 数学 64
  语文 47
  英语 145
  物理 31
  化学 31
  生物 16
  正式考 数学 37
  语文 132
  英语 134
  物理 123
  化学 60
  生物 50
  Name: (期中, 雷军, 测试一), dtype: int32

# 列。索引从列开始取， 必须一层层取， 取完列索引，才可以取行索引
# 先取行索引同理
df5.模拟考.数学.期中.雷军.测试一
1
2
3

• 输出

  64

a=df5['正式考']
a
1
2

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

1. 分析比较Series和DataFrame各种索引的方式，熟练掌握.loc()方法

2. 假设张三再一次在期中考试的时候因为特殊原因放弃英语考试，如何实现？

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

4. 索引的堆（stack）

• stack()
• unstack()

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

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

df2
1

df2.stack()
1

# stack的作用是将列索引变成了行的最内层索引
# level 代表的是层级 -1代表最里层，
df2.stack(level=0)
1
2
3

# unstack是将行变成列的最内层索引
df2.unstack()
1
2

• 输出

  python 期中 东 144
  南 32
  西 32
  北 135
  期末 东 33
  南 140
  西 58
  北 57
  math 期中 东 108
  南 57
  西 38
  北 66
  期末 东 55
  南 15
  西 72
  北 33
  en 期中 东 16
  南 54
  西 45
  北 85
  期末 东 95
  南 70
  西 54
  北 105
  dtype: int32

df5.unstack()
1

4 rows × 24 columns

#如果想把所有的行索引都转成列索引
# 给level一个list,可以解决
df5.unstack(level=[0, 1, 2])
1
2
3

• 输出

  模拟考 数学 期中 李斌 测试一 31
  测试二 67
  雷军 测试一 64
  测试二 147
  期末 李斌 测试一 90
  测试二 30
  雷军 测试一 8
  测试二 31
  语文 期中 李斌 测试一 132
  测试二 20
  雷军 测试一 47
  测试二 101
  期末 李斌 测试一 101
  测试二 37
  雷军 测试一 144
  测试二 77
  英语 期中 李斌 测试一 69
  测试二 87
  雷军 测试一 145
  测试二 25
  期末 李斌 测试一 111
  测试二 15
  雷军 测试一 149
  测试二 73
  物理 期中 李斌 测试一 134
  测试二 145
  雷军 测试一 31
  测试二 119
  期末 李斌 测试一 134
  测试二 98
  …
  正式考 英语 期中 雷军 测试一 134
  测试二 133
  期末 李斌 测试一 15
  测试二 108
  雷军 测试一 49
  测试二 119
  物理 期中 李斌 测试一 36
  测试二 28
  雷军 测试一 123
  测试二 148
  期末 李斌 测试一 83
  测试二 4
  雷军 测试一 84
  测试二 144
  化学 期中 李斌 测试一 9
  测试二 111
  雷军 测试一 60
  测试二 86
  期末 李斌 测试一 66
  测试二 128
  雷军 测试一 93
  测试二 127
  生物 期中 李斌 测试一 77
  测试二 86
  雷军 测试一 50
  测试二 15
  期末 李斌 测试一 33
  测试二 64
  雷军 测试一 83
  测试二 43
  Length: 96, dtype: int32

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

1. 使用unstack()将ddd变为两行，分别为期中期末

2. 使用unstack()将ddd变为四行，分别为四个科目

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

5. 聚合操作

【注意】

• 需要指定axis

• 【小技巧】和unstack()相反，聚合的时候，axis等于哪一个，哪一个就保留。

所谓的聚合操作：平均数，方差，最大值，最小值……

df2.sum(axis=1)
1

• 输出

  东 451
  南 368
  西 299
  北 481
  dtype: int64

df2.mean(axis=1)
1

• 输出

  东 75.166667
  南 61.333333
  西 49.833333
  北 80.166667
  dtype: float64

df2.std(axis=1)
# 方差代表的是数据的波动
1
2

• 输出

  东 48.774652
  南 43.228077
  西 14.538455
  北 36.356109
  dtype: float64

df2.max(axis=1)
1

• 输出

  东 144
  南 140
  西 72
  北 135
  dtype: int32

df2.min(axis=1)
1

• 输出

  东 16
  南 15
  西 32
  北 33
  dtype: int32