Pandas与傅里叶公式应用

Pandas与傅里叶公式应用

# 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

	java	python
0	110.0	100.0
1	120.0	101.0
2	119.0	NaN
3	NaN	NaN

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

# 虽然没有干扰运算，但是降低了计算的效率

• 输出

  java 349.0
  python 201.0
  dtype: float64

df.sum(axis=1)

• 输出

  0 210.0
  1 221.0
  2 119.0
  3 0.0
  dtype: float64

# int->float->object->nan

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

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

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

• 输出
  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()

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

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

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

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

pandas中对于空值的操作

- innull()
- notnull()
- dropna() # 过滤空值
- fillna() # 填充空值

isnull

df

	java	python
0	110.0	100.0
1	120.0	101.0
2	119.0	NaN
3	NaN	NaN

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

	java	python
0	False	False
1	False	False
2	False	True
3	False	True

df[cond]

	java	python
0	NaN	NaN
1	NaN	NaN
2	NaN	NaN
3	NaN	NaN

notnull

cond = df.notnull()
cond

	java	python
0	True	True
1	True	True
2	True	False
3	False	False

df[cond]

	java	python
0	110.0	100.0
1	120.0	101.0
2	119.0	NaN
3	NaN	NaN

any all

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

• 输出

  java True
  python True
  dtype: bool

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

• 输出

  0 False
  1 False
  2 True
  3 True
  dtype: bool

df[cond]

	java	python
2	119.0	NaN
3	NaN	NaN

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

# all条件全部为真， 则返回true

• 输出

  0 False
  1 False
  2 False
  3 True
  dtype: bool

df[cond]

	java	python
3	NaN	NaN

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

• 输出

  0 True
  1 True
  2 False
  3 False
  dtype: bool

df[cond1]

	java	python
0	110.0	100.0
1	120.0	101.0

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

• 输出

  0 True
  1 True
  2 True
  3 False
  dtype: bool

df[cond1]

	java	python
0	110.0	100.0
1	120.0	101.0
2	119.0	NaN

dropna()
过滤NaN

df

	java	python
0	110.0	100.0
1	120.0	101.0
2	119.0	NaN
3	NaN	NaN

df.dropna()

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

	java	python
0	110.0	100.0
1	120.0	101.0

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

	java	python
0	110.0	100.0
1	120.0	101.0
2	119.0	NaN

.add()

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

	java	python
0	110.0	NaN
1	120.0	NaN
2	119.0	100.0
3	NaN	101.0

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

	java	python
0	110.0	100.0
1	120.0	101.0
2	119.0	NaN
3	0.0	NaN

df2 = df.add(df1)
df2

	java	python
0	220.0	NaN
1	240.0	NaN
2	238.0	NaN
3	NaN	NaN

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

	java	python
0	220.0	100.0
1	240.0	101.0
2	238.0	100.0
3	0.0	101.0

fillna() NaN过滤

df4 = df.fillna(value=0)
df4

	java	python
0	110.0	100.0
1	120.0	101.0
2	119.0	0.0
3	0.0	0.0

df1 = df1.fillna(value=0)
df1

	java	python
0	110.0	0.0
1	120.0	0.0
2	119.0	100.0
3	0.0	101.0

df4 + df1

	java	python
0	220.0	100.0
1	240.0	101.0
2	238.0	100.0
3	0.0	101.0

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

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

	java	php	python
0	300	3.0	100
1	100	2.0	200
2	400	NaN	101
3	500	0.0	201

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

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

	java	php	python
0	300.0	3.0	100.0
1	100.0	2.0	200.0
2	400.0	101.0	101.0
3	500.0	0.0	201.0

# 电费
# 2017

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


# 2018 你的数据丢失了
6   70

# 拉格朗日 插值法

傅里叶

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

# 转换二进制
# uint8 255

cat_data = np.fromstring(cat.tobytes(), np.int8)

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.

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

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

• 输出

  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

• 输出

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

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

• 输出

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

cat.mode

• 输出

  ‘RGB’

cat.size

• 输出
  (730, 456)

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

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=10), index = list('qwertyuiop'))
s

• 输出

  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

• 输出

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

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

		python
a	期中	113
	期末	105
b	期中	27
	期末	65
c	期中	111
	期末	11

DataFrame建立2级列索引

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

	python		math		en
	期中	期末	期中	期末	期中	期末
东	49	15	6	32	37	124
南	0	49	100	105	35	73
西	60	134	83	86	52	73
北	12	101	101	6	39	112

2) 显示构造pd.MultiIndex

• 使用数组

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

• 使用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

	python		math		en
	期中	期末	期中	期末	期中	期末
东	111	19	51	125	32	147
南	35	52	97	81	93	1
西	18	12	125	65	136	40
北	110	34	13	52	56	15

• 使用product

  最简单，推荐使用

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

	en		math		python
	期中	期末	期中	期末	期中	期末
东	128	131	1	121	64	5
南	97	60	128	105	87	140
西	128	66	120	55	61	87
北	110	64	69	64	61	77

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

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

			模拟考						正式考
			数学	语文	英语	物理	化学	生物	数学	语文	英语	物理	化学	生物
期中	雷军	测试一	64	47	145	31	31	16	37	132	134	123	60	50
		测试二	147	101	25	119	148	51	76	51	133	148	86	15
	李斌	测试一	31	132	69	134	106	40	78	103	31	36	9	77
		测试二	67	20	87	145	13	67	138	85	133	28	111	86
期末	雷军	测试一	8	144	149	134	109	144	132	67	49	84	93	83
		测试二	31	77	73	22	46	78	72	144	119	144	127	43
	李斌	测试一	90	101	111	134	143	12	124	98	15	83	66	33
		测试二	30	37	15	98	25	83	35	33	108	4	128	64

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

1）Series的操作

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

(1) 索引

s

• 输出

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

s['a', '期中']

• 输出

  113

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

• 输出

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

s.a.期中

• 输出

  113

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

• 输出

  期中 113
  期末 105
  dtype: int32

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

• 输出

  113

(2) 切片

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

• 输出

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

2）DataFrame的操作

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

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

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

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

df5

			模拟考						正式考
			数学	语文	英语	物理	化学	生物	数学	语文	英语	物理	化学	生物
期中	雷军	测试一	64	47	145	31	31	16	37	132	134	123	60	50
		测试二	147	101	25	119	148	51	76	51	133	148	86	15
	李斌	测试一	31	132	69	134	106	40	78	103	31	36	9	77
		测试二	67	20	87	145	13	67	138	85	133	28	111	86
期末	雷军	测试一	8	144	149	134	109	144	132	67	49	84	93	83
		测试二	31	77	73	22	46	78	72	144	119	144	127	43
	李斌	测试一	90	101	111	134	143	12	124	98	15	83	66	33
		测试二	30	37	15	98	25	83	35	33	108	4	128	64

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

			语文	数学
期中	雷军	测试一	47	64
		测试二	101	147
	李斌	测试一	132	31
		测试二	20	67
期末	雷军	测试一	144	8
		测试二	77	31
	李斌	测试一	101	90
		测试二	37	30

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

• 输出

  64

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

• 输出

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

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

• 输出

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

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

• 输出

  64

a=df5['正式考']
a

			数学	语文	英语	物理	化学	生物
期中	雷军	测试一	37	132	134	123	60	50
		测试二	76	51	133	148	86	15
	李斌	测试一	78	103	31	36	9	77
		测试二	138	85	133	28	111	86
期末	雷军	测试一	132	67	49	84	93	83
		测试二	72	144	119	144	127	43
	李斌	测试一	124	98	15	83	66	33
		测试二	35	33	108	4	128	64

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

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

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

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

4. 索引的堆（stack）

• stack()
• unstack()

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

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

df2

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

df2.stack()

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

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

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

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

• 输出

  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()

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

4 rows × 24 columns

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

• 输出

  模拟考 数学 期中 李斌 测试一 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)

• 输出

  东 451
  南 368
  西 299
  北 481
  dtype: int64

df2.mean(axis=1)

• 输出

  东 75.166667
  南 61.333333
  西 49.833333
  北 80.166667
  dtype: float64

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

• 输出

  东 48.774652
  南 43.228077
  西 14.538455
  北 36.356109
  dtype: float64

df2.max(axis=1)

• 输出

  东 144
  南 140
  西 72
  北 135
  dtype: int32

df2.min(axis=1)

• 输出

  东 16
  南 15
  西 32
  北 33
  dtype: int32