【一周一库，拒绝堕落】 pandas笔记，我觉得有用的东西都放进去了！

最近热门博客都是一些职场面试啥的，我呢，还是个学生，不掺和这场职业博文，还是写点干货，分享给所有像我这样喜欢学习的人，一起进步，也是为了以后的职业规划，我自学python也快三个月了吧，最后还是选择了数据分析和机器算法这条路，前段时间也写完了numpy的解析，不看你一定后悔，基于 Numpy 的满满干货，你还在等什么呢？，就是这篇，不知道python的路怎么走，跟着跟着我的笔记学习，也一定有帮助的，后面我还会扩展其他笔记，关注我，别迷路！

Pandas 是 Python 中的数据操纵和分析软件包，也是一个强大的数据分析库，其中包含很多函数和功能！我个人感觉前提一定要学numpy，这样知识点就能记得更全面点！

导入扩展库

import pandas as pd

创建一个Pandas序列

pds = pd.Series(index = ['chinese', 'math', 'English', 'computer'], data = [100, 99, 98, 97])
print(pds)
print('形状=',pds.shape)
print('维度=',pds.ndim)
print('大小=',pds.size)
print(f'pds序列包括的标签=\t{pds.index}\npds序列包括的值= \t{pds.values}')

chinese     100
math         99
English      98
computer     97
dtype: int64
形状= (4,)
维度= 1
大小= 4
pds序列包括的标签=	Index(['chinese', 'math', 'English', 'computer'], dtype='object')
pds序列包括的值= 	[100  99  98  97]

判断标签或者值是否存在

当我们的数据很大，可能会忘记我们设置过的标签或者值，那我们使用in关键词，而这个我们都学过的，用in关键词判断可以返回布尔值

x = 'math' in pds
print(f'问:math是不是在标签里面呢？\t\t答:{x}')
y =  '95' in pds
print(f'问:95分是不是在值里面呢? \t\t答:{y}')

问:math是不是在标签里面呢？		答:True
问:95分是不是在值里面呢? 		答:False

序列的访问

pandas的序列访问多种多样，这里我们先通过标签索引或者下标索引

PS： 如果你使用的是和我一样f格式输出，记住，这里使用的索引方法pds[‘math’]，但二个引号’’ 和""一定要注意，一定不能和print的引号一样，否则一定是语法错误！当然pandas也注意到了这一点，后面有更好的方法来索引

%pdb
pds = pd.Series(index = ['chinese', 'math', 'English', 'computer'], data = [100, 99, 98, 97])
print(pds)
print()
print(f"当我们使用标签索引math时:\tmath -->{pds['math']}")
print(f"当我们使用标签索引多个时:\tmath,chinese -->\n{pds[['math', 'chinese']]}")
print()
print(f'当我们使用下标索引第一个时:\t-->{pds[0]}')
print(f'当我们使用下标索引多个时:\t\n{pds[[0,1]]}')

Automatic pdb calling has been turned ON
chinese     100
math         99
English      98
computer     97
dtype: int64

当我们使用标签索引math时:	math -->99
当我们使用标签索引多个时:	math,chinese -->
math        99
chinese    100
dtype: int64

当我们使用下标索引第一个时:	-->100
当我们使用下标索引多个时:	
chinese    100
math        99
dtype: int64

• 对于上面的索引方式，你们感觉咋样，脑袋现在是不是有点晕晕的，既可以标签索引也可以下标索引，那下面我们换个索引方式，这样就能表达的就很清晰，在pandas序列存在二个属性，.loc 和 .iloc loc表示的是标签索引，iloc表示的下标索引，我们来看二个例子。

print(f"使用loc属性用于标签索引,获得math对应分数-->{pds.loc['math']}")
print(f"使用iloc属性用于下标索引，获得第一个分数-->{pds.iloc[0]}")

使用loc属性用于标签索引,获得math对应分数-->99
使用iloc属性用于下标索引，获得第一个分数-->100

对序列赋值修改

pandas和numpy一样都是可以修改的，方法一样的，直接赋值修改就可以,那我们试着如何赋值修改吧

print(pds)
print('-'*40)
pds['chinese'] = 80
print(pds)

chinese     100
math         99
English      98
computer     97
dtype: int64
----------------------------------------
chinese     80
math        99
English     98
computer    97
dtype: int64

对序列进行删除

我们还可以使用 .drop() 方法删除 Pandas序列中的标签和值。但是注意，Series.drop(label) 方法不在原序列从 Series 中删除元素，即不会更改被修改的原始 Series，那如果我们要更改原序列的值呢，在括号里面加入参数 inplace = True 就行

print(pds)
print('-' * 40)
print(f"当我们删除数学:\n{pds.drop('math')}")
print('-' * 40)
print(f"原序列:\n{pds}")
print('-' * 40)
print(f"当我们加入参数:\n{pds.drop('math', inplace = True)},\t这样就没有返回序列，即对原序列进行操作")
print('-' * 40)
print(f'原序列:\n{pds}')

chinese     80
math        99
English     98
computer    97
dtype: int64
----------------------------------------
当我们删除数学:
chinese     80
English     98
computer    97
dtype: int64
----------------------------------------
原序列:
chinese     80
math        99
English     98
computer    97
dtype: int64
----------------------------------------
当我们加入参数:
None,	这样就没有返回序列，即对原序列进行操作
----------------------------------------
原序列:
chinese     80
English     98
computer    97
dtype: int64

对序列进行算数运算

和numpy一样，pandas序列也可以进行算数运算，但是如果要进行乘除操作，一定得注意类型一致，比如值中既有数字又有字符串，那么操作会出错

import numpy as np
import pandas as pd

fruits = pd.Series(index=['apple', 'banana','orange'], data = [8, 5, 3])
print(f'建立一个水果序列\n{fruits}\n')
print(f'水果涨价 + 2\n{fruits + 2}\n')
print(f'水果贱卖 - 4\n{fruits - 2}\n')
print(f'apple涨价 + 2  =  {fruits.loc["apple"] + 2}\n')
print(f'banana,orange半价\n {fruits.loc[["banana", "orange"]] / 2}')

建立一个水果序列
apple     8
banana    5
orange    3
dtype: int64

水果涨价 + 2
apple     10
banana     7
orange     5
dtype: int64

水果贱卖 - 4
apple     6
banana    3
orange    1
dtype: int64

apple涨价 + 2  =  10

banana,orange半价
 banana    2.5
orange    1.5
dtype: float64

对序列进行数学函数计算

同样，基于numpy之上，pandas当然有理由使用numpy的内置函数，比如数学函数

import numpy as np
import pandas as pd

fruits = pd.Series(index=['apple', 'banana','orange'], data = [8, 5, 3])
print(f'水果价格平方\n{np.power(fruits, 2)}\n')
print(f'水果价格开方\n{np.sqrt(fruits)}\n')

水果价格平方
apple     64
banana    25
orange     9
dtype: int64

水果价格开方
apple     2.828427
banana    2.236068
orange    1.732051
dtype: float64

创建一个pandas DataFrames

Pandas DataFrames 是具有带标签的行和列的二维数据结构，可以存储很多类型的数据。感觉类似excel表格，我们首先用pandas序列创建一个字典fruits，然后用 DataFrame() 函数把这个字典加载进去，就可以得到，下面我用水果的例子试试

import pandas as pd
fruits = {'Bob':pd.Series(data = [3, 4, 5, 8], index = ['orange', 'bananas', 'apple','pomegranate']),
          'Alice':pd.Series(data = [3.5, 4, 6, 2], index = ['bananas', 'apple', 'orange','watermelon'])}

print('字典类型:\t',type(fruits))
print()

fruit_items = pd.DataFrame(fruits)
print('fruit DataFrames \n',fruit_items)

字典类型:	 <class 'dict'>

fruit DataFrames 
              Bob  Alice
apple        5.0    4.0
bananas      4.0    3.5
orange       3.0    6.0
pomegranate  8.0    NaN
watermelon   NaN    2.0

这个水果数据框是不是很像excel表格呢，行表头是根据字典的键来确定的，列表头是根据字母排序来确定的，我们也可以看到NaN值，它的意思是非数字，从上面看到bob没卖西瓜，alice没有卖石榴，没有值，所以用NaN代替，这个先放这里，后面我们在讲怎么去掉这个值，下面讲一讲如果序列里面没有标签

import pandas as np
scores = {'小明':pd.Series(data = [100, 100, 100]), '小红':pd.Series(data = [99, 100, 98])}
s1_item = pd.DataFrame(scores)
print(f"当我们在序列里面不加入标签的时候\n{s1_item}")

print('-' * 40)
print('系统会默认用数字作为标签，当然这个数字是从0开始')

当我们在序列里面不加入标签的时候
    小明   小红
0  100   99
1  100  100
2  100   98
----------------------------------------
系统会默认用数字作为标签，当然这个数字是从0开始

DataFrames 属性

同numpy一样，pandas也可以使用如下属性进行访问

• shape 形状
• ndim 维度
• size 大小
• index 行标签
• values 值
• columns 列标签

import pandas as pd

fruits = {'Bob':pd.Series(data = [3, 4, 5, 8], index = ['orange', 'bananas', 'apple','pomegranate']),
          'Alice':pd.Series(data = [3.5, 4, 6, 2], index = ['bananas', 'apple', 'orange','watermelon'])}

fruit_item = pd.DataFrame(fruits) #还是用上面的水果来创建一个数据框


print(fruit_item)
print()

print(f'shape形状 = {fruit_item.shape}')
print(f'ndim维度 = {fruit_item.ndim}')
print(f'size大小 = {fruit_item.size}')
print(f'index行标签 = {fruit_item.index}\n')
print(f'values值 = {fruit_item.values}\n')
print(f'columns列标签 = {fruit_item.columns}')

             Bob  Alice
apple        5.0    4.0
bananas      4.0    3.5
orange       3.0    6.0
pomegranate  8.0    NaN
watermelon   NaN    2.0

shape形状 = (5, 2)
ndim维度 = 2
size大小 = 10
index行标签 = Index(['apple', 'bananas', 'orange', 'pomegranate', 'watermelon'], dtype='object')

values值 = [[5.  4. ]
 [4.  3.5]
 [3.  6. ]
 [8.  nan]
 [nan 2. ]]

columns列标签 = Index(['Bob', 'Alice'], dtype='object')

有了上面的属性方法，那我们的操作一下子就变得简单多了,也变得多种多样，可以使用index和columns关键词进行筛选，下面我给点例子

fruits = {'Bob':pd.Series(data = [3, 4, 5, 8], index = ['orange', 'bananas', 'apple','pomegranate']),
          'Alice':pd.Series(data = [3.5, 4, 6, 2], index = ['bananas', 'apple', 'orange','watermelon'])}


fruit_item1 = pd.DataFrame(fruits, index = ['apple', 'bananas'])
print(f'我们只需要苹果和香蕉\n\n{fruit_item1}\n')
print('- ' * 40)
fruit_item2 = pd.DataFrame(fruits, columns=['Bob'])
print(f'我们只看bob的数据\n\n{fruit_item2}\n')
print('- ' * 40)
fruit_item3 = pd.DataFrame(fruits, index = ['apple'] , columns=['Alice'])
print(f'我们只看Alice的苹果\n\n{fruit_item3}\n')

我们只需要苹果和香蕉

         Bob  Alice
apple      5    4.0
bananas    4    3.5

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我们只看bob的数据

             Bob
orange         3
bananas        4
apple          5
pomegranate    8

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我们只看Alice的苹果

       Alice
apple    4.0

DataFrames 的其他创建方式

在上面的实例中，我们的字典里面都是使用pandas的序列，其实也可以使用其他的方式，比如列表或者字典，看这个例子

ps：列表或者字典，二个对象的长度一定一致

scores = {'bob': [100,99,98], 'tom':[98,92,100]}
score_item = pd.DataFrame(scores, index = ['第一次测试', '第二次测试', '第三次测试'])
print(score_item)

       bob  tom
第一次测试  100   98
第二次测试   99   92
第三次测试   98  100

DataFrames 元素的访问

print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)
print(f'这里规定的是先访问列标签，然后访问行标签')
print()
print(f'我们查看自行车和手表的库存\n{store[["bikes", "watches"]]}')
print('- ' * 40)
print(f'我们查看一号店库存\n{store.loc[["1-store"]]}')
print()
print('这里用到了序列标签查找方式 loc 忘记的赶紧往上翻')
print('- ' * 40)
print(f'我们看一号店的自行车库存 = {store["bikes"]["1-store"]}')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
这里规定的是先访问列标签，然后访问行标签

我们查看自行车和手表的库存
         bikes  watches
1-store     20       35
2-store     15       10
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我们查看一号店库存
         bikes  pants  watches  glasses
1-store     20     30       35      NaN

这里用到了序列标签查找方式 loc 忘记的赶紧往上翻
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我们看一号店的自行车库存 = 20

DataFrames 行列增加

print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)
store['jake'] = [10, 20]
print(f'我们增加一个商品jake\n{store}')
print('- ' * 40)
store_new = [{'bikes':30, 'pants':23, 'watches':21, 'jake':40}]
store3 = pd.DataFrame(store_new, index = ['3-store'])
store = store.append(store3)
print(f'我们增加一行 3-store\n{store}')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我们增加一个商品jake
         bikes  pants  watches  glasses  jake
1-store     20     30       35      NaN    10
2-store     15      5       10     50.0    20
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我们增加一行 3-store
         bikes  pants  watches  glasses  jake
1-store     20     30       35      NaN    10
2-store     15      5       10     50.0    20
3-store     30     23       21      NaN    40

这里增加用到了函数.append() 使用方法在代码内

DataFrames 元素插入

函数dataframe.insert(loc,label,data) 可以让我们在任意列中插入

print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)
store.insert(0, 'jake',[10, 20])
print(f'在第0个位置上插入jake\n{store}')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
在第0个位置上插入jake
         jake  bikes  pants  watches  glasses
1-store    10     20     30       35      NaN
2-store    20     15      5       10     50.0

DataFrames 元素删除

对于序列我们讲到过drop()方法，这里同样使用，加入参数axis 就可以选择行和列了，当然还有一个独特的方法pop，但是pop只能删除列，看点例子

print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)
store.pop("bikes")
print(f'使用pop删除bikes\n{store}')
print('- ' * 40)
store = store.drop('pants', axis = 1)
print(f'使用drop删除pants\n{store}')
print('- ' * 40)
store = store.drop('1-store', axis = 0)
print(f'使用drop删除第一行\n{store}')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用pop删除bikes
         pants  watches  glasses
1-store     30       35      NaN
2-store      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用drop删除pants
         watches  glasses
1-store       35      NaN
2-store       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用drop删除第一行
         watches  glasses
2-store       10     50.0

DataFrames 标签改名

函数DataFrame.rename() 可以给行标签 或者 列标签 进行改名操作

print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35}, 
          {'watches': 10, 'glasses': 50, 'bikes': 15, 'pants':5}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store'])
print(store)
print('- ' * 40)

store1 = store.rename(columns = {'bikes':"jake"})
print(f'我们改列标签 bike改成jake \n{store1}')
print('- ' * 40)
store2 = store.rename(index = {'1-store':'3-store'})
print(f'我们改行标签  1 改成 3 \n{store2}')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store     20     30       35      NaN
2-store     15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我们改列标签 bike改成jake 
         jake  pants  watches  glasses
1-store    20     30       35      NaN
2-store    15      5       10     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我们改行标签  1 改成 3 
         bikes  pants  watches  glasses
3-store     20     30       35      NaN
2-store     15      5       10     50.0

NaN的处理手法

我们前面也涉及到NaN值，当缺少某个值的时候，dadaframe就会给他赋值NaN，但是在我们后面的计算，我们不希望出现这么多NaN值，所以我们也有方法

NaN值的总数计算

这里使用 dataframe.isnull() 和sum()来计算NaN的总数 ,使用方法是
isnull().sum().sum() 这里就会感觉很奇怪，为什么二个sum，那下面我们一个个来看

print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意准备了一个NaN多的例子看看')
print('- ' * 40)
print(f'先看看isnull有啥用\n{store.isnull()}')
print(f'对比上表，NaN被替换成了布尔值的True，其他则是False')
print('- ' * 40)
print(f'再看看一个sum \n{store.isnull().sum()}')
print('对比上表，可以看到，这步只是计算了每个标签中的NaN的值')
print('- ' * 40)
print(f'最后二个sum可以得到全部NaN值 = {store.isnull().sum().sum()}')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意准备了一个NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
先看看isnull有啥用
         bikes  pants  watches  glasses
1-store  False  False    False     True
2-store   True  False    False    False
3-store  False  False    False     True
对比上表，NaN被替换成了布尔值的True，其他则是False
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
再看看一个sum 
bikes      1
pants      0
watches    0
glasses    2
dtype: int64
对比上表，可以看到，这步只是计算了每个标签中的NaN的值
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
最后二个sum可以得到全部NaN值 = 3

NaN值的删除

使用 dataframe.dropna(axis)

axis = 0 删除行， axis = 1 删除列

print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10, 'glasses':20}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意准备了一个NaN多的例子看看')
print('- ' * 40)
store1 =  store.dropna(axis = 0)
print(f'删除行中有NaN值 \n{store1}')
print('- ' * 40)
store2 = store.dropna(axis = 1)
print(f'删除列中有NaN值 \n {store2}')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20     20.0
特意准备了一个NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
删除行中有NaN值 
         bikes  pants  watches  glasses
3-store   10.0     21       20     20.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
删除列中有NaN值 
          pants  watches
1-store     30       35
2-store      5       10
3-store     21       20

NaN值的更改

下面提到多种方法可以对NaN值的修改，具体使用还得根据实际情况来，怎么能消去就怎么弄，不要在意为什么会有什么多方法

修改为某值

使用函数dataframe.fillna() 加入要改后的值就行

print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意准备了一个NaN多的例子看看')
print('- ' * 40)
store1 = store.fillna(0)
print(f'这里我把所有的NaN值全部改为0\n{store1}')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意准备了一个NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
这里我把所有的NaN值全部改为0
         bikes  pants  watches  glasses
1-store   20.0     30       35      0.0
2-store    0.0      5       10     50.0
3-store   10.0     21       20      0.0

向前填充

使用dataframe.fill(method = ‘ffill’, axis) 函数，我们可以将NaN值，向前填充，其中axis选择上还是左，看点例子

import pandas as pd
print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意准备了一个NaN多的例子看看')
print('- ' * 40)
store1 = store.fillna(method = 'ffill', axis = 0)
print(f'这里我们先选择向上填充\n{store1}\n')
print('1-store 中的 NaN 由于上面没有数值， 所以保留原样')
print('- ' * 40)
store2 = store.fillna(method = 'ffill', axis = 1)
print(f'这里我们选择向左填充\n{store2}')
print('至于为什么还有一个NaN值，大家应该知道原因了吧')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意准备了一个NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
这里我们先选择向上填充
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store   20.0      5       10     50.0
3-store   10.0     21       20     50.0

1-store 中的 NaN 由于上面没有数值， 所以保留原样
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
这里我们选择向左填充
         bikes  pants  watches  glasses
1-store   20.0   30.0     35.0     35.0
2-store    NaN    5.0     10.0     50.0
3-store   10.0   21.0     20.0     20.0
至于为什么还有一个NaN值，大家应该知道原因了吧

向后填充

使用 dataframe.fillna(method = ‘backfill’, axis) 可以向后填充，用法和上面类似

import pandas as pd
print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意准备了一个NaN多的例子看看')
print('- ' * 40)
store1 = store.fillna(method = 'backfill', axis = 0)
print(f'这里我们选择向下填充\n{store1}')
print('- ' * 40)
store2 = store.fillna(method = 'backfill', axis = 1)
print(f'这里我们选择向右填充\n{store2}')
print('同样的理由可以解释为什么还有NaN值')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意准备了一个NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
这里我们选择向下填充
         bikes  pants  watches  glasses
1-store   20.0     30       35     50.0
2-store   10.0      5       10     50.0
3-store   10.0     21       20      NaN
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
这里我们选择向右填充
         bikes  pants  watches  glasses
1-store   20.0   30.0     35.0      NaN
2-store    5.0    5.0     10.0     50.0
3-store   10.0   21.0     20.0      NaN
同样的理由可以解释为什么还有NaN值

对差填充

使用 dataframe.interpolate(method = ‘linear’, axis) 可以差值填充，依旧来看看

import pandas as pd
print('我们先创建一个数据框,这里用到的是字典列表')
print('- ' * 40)
store_item = [{'bikes': 20, 'pants': 30, 'watches': 35},\
             {'watches': 10, 'glasses': 50,  'pants':5},\
             {'pants':21, 'watches':20, 'bikes':10}]
store = pd.DataFrame(store_item, index = ['1-store', '2-store', '3-store'])
print(store)
print('特意准备了一个NaN多的例子看看')
print('- ' * 40)
store1 = store.interpolate(method = 'linear', axis = 0)
print(f'向上求等差填充\n{store1}')
print('- ' * 40)
store2 = store.interpolate(method = 'linear', axis = 1)
print(f'向左求等差填充\n{store2}')

我们先创建一个数据框,这里用到的是字典列表
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store    NaN      5       10     50.0
3-store   10.0     21       20      NaN
特意准备了一个NaN多的例子看看
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
向上求等差填充
         bikes  pants  watches  glasses
1-store   20.0     30       35      NaN
2-store   15.0      5       10     50.0
3-store   10.0     21       20     50.0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
向左求等差填充
         bikes  pants  watches  glasses
1-store   20.0   30.0     35.0     35.0
2-store    NaN    5.0     10.0     50.0
3-store   10.0   21.0     20.0     20.0

读取CSV文件获得DataFrames

获得数据和数据属性

我们用函数pd.read_csv() 可以从CSV文件中将数据加载出来

import pandas as pd
good_data  = pd.read_csv('goog-1.csv', encoding = 'utf-8')
print(f'这里我们从网上找到的一个数据，先获得基础属性')
print('- ' * 40)
print(type(good_data))
print(good_data.shape)
print('- ' * 40)
print(f'使用函数.head(N)  可以获得数据的前N项 默认 N = 5 \n{good_data.head()}')
print('- ' * 40)
print(f'使用函数.tail(N)  可以获得数据的后N项 默认 N = 5\n {good_data.tail()}')

这里我们从网上找到的一个数据，先获得基础属性
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
<class 'pandas.core.frame.DataFrame'>
(3313, 7)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用函数.head(N)  可以获得数据的前N项 默认 N = 5 
         Date       Open       High        Low      Close  Adj Close    Volume
0  2004-08-19  49.676899  51.693783  47.669952  49.845802  49.845802  44994500
1  2004-08-20  50.178635  54.187561  49.925285  53.805050  53.805050  23005800
2  2004-08-23  55.017166  56.373344  54.172661  54.346527  54.346527  18393200
3  2004-08-24  55.260582  55.439419  51.450363  52.096165  52.096165  15361800
4  2004-08-25  52.140873  53.651051  51.604362  52.657513  52.657513   9257400
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
使用函数.tail(N)  可以获得数据的后N项 默认 N = 5
             Date        Open        High         Low       Close   Adj Close  \
3308  2017-10-09  980.000000  985.424988  976.109985  977.000000  977.000000   
3309  2017-10-10  980.000000  981.570007  966.080017  972.599976  972.599976   
3310  2017-10-11  973.719971  990.710022  972.250000  989.250000  989.250000   
3311  2017-10-12  987.450012  994.119995  985.000000  987.830017  987.830017   
3312  2017-10-13  992.000000  997.210022  989.000000  989.679993  989.679993   

       Volume  
3308   891400  
3309   968400  
3310  1693300  
3311  1262400  
3312  1157700  

检测数据是否存在NaN值

print('可以使用之前的方法 .isnull.sum().sum() = ',good_data.isnull().sum().sum())
print('- ' * 40)
print(f'这里学一个新方法 isnull().any() \n\n{good_data.isnull().any()}')
print()
print('any()作用在isnull() 上，显示每列是否存在NaN值')

可以使用之前的方法 .isnull.sum().sum() =  0
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
这里学一个新方法 isnull().any() 

Date         False
Open         False
High         False
Low          False
Close        False
Adj Close    False
Volume       False
dtype: bool

any()作用在isnull() 上，显示每列是否存在NaN值

加载数据的重要信息

我们使用函数 .describe() 可以获得这个数据的重要信息，便于我们处理，还是上面的数据作为例子

good_data.describe()

	Open	High	Low	Close	Adj Close	Volume
count	3313.000000	3313.000000	3313.000000	3313.000000	3313.000000	3.313000e+03
mean	380.186092	383.493740	376.519309	380.072458	380.072458	8.038476e+06
std	223.818650	224.974534	222.473232	223.853780	223.853780	8.399521e+06
min	49.274517	50.541279	47.669952	49.681866	49.681866	7.900000e+03
25%	226.556473	228.394516	224.003082	226.407440	226.407440	2.584900e+06
50%	293.312286	295.433502	289.929291	293.029114	293.029114	5.281300e+06
75%	536.650024	540.000000	532.409973	536.690002	536.690002	1.065370e+07
max	992.000000	997.210022	989.000000	989.679993	989.679993	8.276810e+07

print(f'其实还可以采集某个特定的数\n\t\tOpen\n{good_data["Open"].describe()}')
print('- ' * 40)
print(f'或者用数学函数等等\n\t\tMax\n{good_data.max()}')

其实还可以采集某个特定的数
		Open
count    3313.000000
mean      380.186092
std       223.818650
min        49.274517
25%       226.556473
50%       293.312286
75%       536.650024
max       992.000000
Name: Open, dtype: float64
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
或者用数学函数等等
		Max
Date         2017-10-13
Open                992
High             997.21
Low                 989
Close            989.68
Adj Close        989.68
Volume         82768100
dtype: object

数据相关性

使用函数**.corr()** 可以知道数据是否关联，越接近1 表示数据越关联

good_data.corr()

	Open	High	Low	Close	Adj Close	Volume
Open	1.000000	0.999904	0.999845	0.999745	0.999745	-0.564258
High	0.999904	1.000000	0.999834	0.999868	0.999868	-0.562749
Low	0.999845	0.999834	1.000000	0.999899	0.999899	-0.567007
Close	0.999745	0.999868	0.999899	1.000000	1.000000	-0.564967
Adj Close	0.999745	0.999868	0.999899	1.000000	1.000000	-0.564967
Volume	-0.564258	-0.562749	-0.567007	-0.564967	-0.564967	1.000000

数据分组

使用函数 .groupby() 可以把不同属性的数据分成一个组，然后进行数学运算，比如求和，平均

data = pd.Series(data = ['3-1','3-1','3-2','3-3'])
spend = pd.Series(data = [10, 11, 13, 15])
get = pd.Series(data = [0, 10, 5, 2])
day_item = {'data':data,
           'spend':spend,
           'get':get}
days = pd.DataFrame(day_item)
print('创建消费数据 \n ',days)
print('- ' * 40)
print(f'我们算算这些天花了多少钱\n {days.groupby(["data"])["spend"].sum()}')
print('- ' * 40)
print(f'算算平均每天得到多少钱\n {days.groupby(["data"])["get"].mean()}')

创建消费数据 
    data  spend  get
0  3-1     10    0
1  3-1     11   10
2  3-2     13    5
3  3-3     15    2
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
我们算算这些天花了多少钱
 data
3-1    21
3-2    13
3-3    15
Name: spend, dtype: int64
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
算算平均每天得到多少钱
 data
3-1    5
3-2    5
3-3    2
Name: get, dtype: int64

愿你我始终走在内心的崎岖小路，一人一码，播出属于自己的种子！