【学习笔记】 第05章 pandas入门
前言
上一篇学习中学成的随笔是我的第一篇随笔，撰写中有颇多不足，比如事无巨细的写入学习过程反而像是在抄书，失去了很多可读性也不利于自己反过头来复习，本章节学习需要多加注意，尽量写下较为关键的内容，犯下的错误，难以理解的概念等等
pandas含有使数据清洗和分析工作变得更快更简单的数据结构和操作工具。pandas经常和其它工具一同使用，如数值计算工具NumPy和SciPy，分析库statsmodels和scikit-learn，和数据可视化库matplotlib。pandas是基于NumPy数组构建的，特别是基于数组的函数和不使用for循环的数据处理。
虽然pandas采用了大量的NumPy编码风格，但二者最大的不同是pandas是专门为处理表格和混杂数据设计的。而NumPy更适合处理统一的数值数组数据。
pandas的数据结构介绍
Series和DataFrame
Series
Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成。
这里可以通过Series 的values和index属性获取其数组表示形式和索引对象
In [13]: obj.values
Out[13]: array([ 4, 7, -5, 3])
In [14]: obj.index # like range(4)
Out[14]: RangeIndex(start=0, stop=4, step=1)
如果需要所创建的Series带有一个可以对各个数据点进行标记的索引，则
obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
即可
与普通NumPy数组相比，你可以通过索引的方式选取Series中的单个或一组值，而使用NumPy函数或类似NumPy的运算（如根据布尔型数组进行过滤、标量乘法、应用数学函数等）都会保留索引值的链接
如果数据被存放在一个Python字典中，也可以直接通过这个字典来创建Series：
In [26]: sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
In [27]: obj3 = pd.Series(sdata)
而如果传入一个字典，该字典与series值无法一一对应（缺少对应），则该位置结果会变成NaN（非数字）
pandas的isnull和notnull函数可用于检测缺失数据
对于许多应用而言，Series最重要的一个功能是，它会根据运算的索引标签自动对齐数据，和数据库的join操作类似
serie有一个name属性，可以为数据和数据项起名
In [38]: obj4.name = 'population'
In [39]: obj4.index.name = 'state'
In [40]: obj4
Out[40]:
state
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
Name: population, dtype: float64
series的索引可以通过赋值的方式就地修改
DataFrame
DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。DataFrame中的数据是以一个或多个二维块存放的（而不是列表、字典或别的一维数据结构）。
建DataFrame的办法有很多，最常用的一种是直接传入一个由等长列表或NumPy数组组成的字
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
'year': [2000, 2001, 2002, 2001, 2002, 2003],
'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data)
其中，panda里的head方法会选取前五行
如果指定了列序列，则DataFrame的列就会按照指定顺序进行排列
如果传入的列在数据中找不到，就会在结果中产生缺失值
通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series
…………（把所有代码均进行了实现）
In [9]: data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
...: 'year': [2000, 2001, 2002, 2001, 2002, 2003],
...: 'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
In [10]: frame = pd.DataFrame(data)
In [11]: frame
Out[11]:
state year pop
0 Ohio 2000 1.5
1 Ohio 2001 1.7
2 Ohio 2002 3.6
3 Nevada 2001 2.4
4 Nevada 2002 2.9
5 Nevada 2003 3.2
In [12]: pd.DataFrame(data, columns=['year', 'state', 'pop'])
Out[12]:
year state pop
0 2000 Ohio 1.5
1 2001 Ohio 1.7
2 2002 Ohio 3.6
3 2001 Nevada 2.4
4 2002 Nevada 2.9
5 2003 Nevada 3.2
In [13]: frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
...: ....: index=['one', 'two', 'three', 'four',
...: ....: 'five', 'six'])
In [14]: frame2
Out[14]:
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 NaN
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 NaN
five 2002 Nevada 2.9 NaN
six 2003 Nevada 3.2 NaN
In [15]: frame2.state
Out[15]:
one Ohio
two Ohio
three Ohio
four Nevada
five Nevada
six Nevada
Name: state, dtype: object
In [16]: frame2.debt=16.5
In [17]: frame2
Out[17]:
year state pop debt
one 2000 Ohio 1.5 16.5
two 2001 Ohio 1.7 16.5
three 2002 Ohio 3.6 16.5
four 2001 Nevada 2.4 16.5
five 2002 Nevada 2.9 16.5
six 2003 Nevada 3.2 16.5
In [18]: frame2['debt'] = np.arange(6.)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-18-f6c7820e8a60> in <module>
----> 1 frame2['debt'] = np.arange(6.)
NameError: name 'np' is not defined
In [19]: import numpy as np
In [20]: frame2['debt'] = np.arange(6.)
In [21]: frame2
Out[21]:
year state pop debt
one 2000 Ohio 1.5 0.0
two 2001 Ohio 1.7 1.0
three 2002 Ohio 3.6 2.0
four 2001 Nevada 2.4 3.0
five 2002 Nevada 2.9 4.0
six 2003 Nevada 3.2 5.0
In [22]: frame2['eastern'] = frame2.state == 'Ohio'
In [23]: frame2
Out[23]:
year state pop debt eastern
one 2000 Ohio 1.5 0.0 True
two 2001 Ohio 1.7 1.0 True
three 2002 Ohio 3.6 2.0 True
four 2001 Nevada 2.4 3.0 False
five 2002 Nevada 2.9 4.0 False
six 2003 Nevada 3.2 5.0 False
In [24]: del frame2['eastern']
In [25]: frame2
Out[25]:
year state pop debt
one 2000 Ohio 1.5 0.0
two 2001 Ohio 1.7 1.0
three 2002 Ohio 3.6 2.0
four 2001 Nevada 2.4 3.0
five 2002 Nevada 2.9 4.0
six 2003 Nevada 3.2 5.0
In [26]: pop = {'Nevada': {2001: 2.4, 2002: 2.9},
...: ....: 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
In [27]: frame3 = pd.DataFrame(pop)
In [28]: frame3
Out[28]:
Nevada Ohio
2001 2.4 1.7
2002 2.9 3.6
2000 NaN 1.5
索引对象
不可变的属性，可以使index在不同的数据结构之间共享
基本功能
重新索引
丢弃指定轴上的项
丢弃某条轴上的一个或多个项很简单，只要有一个索引数组或列表即可。由于需要执行一些数据整理和集合逻辑，所以drop方法返回的是一个在指定轴上删除了指定值的新对象
索引、选取和过滤
利用标签的切片运算与普通的Python切片运算不同，其末端是包含的
In [125]: obj['b':'c']
Out[125]:
b 1.0
c 2.0
dtype: float64
学习了以下代码
In [82]: data[:2]
Out[82]:
one two three four
Ohio 0 1 2 3
Colorado 4 5 6 7
In [83]: data
Out[83]:
one two three four
Ohio 0 1 2 3
Colorado 4 5 6 7
Utah 8 9 10 11
New York 12 13 14 15
In [84]: data[data['three'] > 5]
Out[84]:
one two three four
Colorado 4 5 6 7
Utah 8 9 10 11
New York 12 13 14 15
In [85]: data < 5
Out[85]:
one two three four
Ohio True True True True
Colorado True False False False
Utah False False False False
New York False False False False
In [86]: data[data < 5] = 0
In [87]: data
Out[87]:
one two three four
Ohio 0 0 0 0
Colorado 0 5 6 7
Utah 8 9 10 11
New York 12 13 14 15
用loc和iloc进行选取
对于DataFrame的行的标签索引，我引入了特殊的标签运算符loc和iloc。它们可以让你用类似NumPy的标记，使用轴标签（loc）或整数索引（iloc），从DataFrame选择行和列的子集
整数索引
由于歧义问题，
In [93]: ser = pd.Series(np.arange(3.))
In [94]: ser
Out[94]:
0 0.0
1 1.0
2 2.0
dtype: float64
In [95]: ser[-1]
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
C:\ProgramData\Anaconda3\lib\site-packages\pandas\core\indexes\range.py in get_loc(self, key, method, tolerance)
384 try:
--> 385 return self._range.index(new_key)
386 except ValueError as err:
ValueError: -1 is not in range
The above exception was the direct cause of the following exception:
KeyError Traceback (most recent call last)
<ipython-input-95-44969a759c20> in <module>
----> 1 ser[-1]
C:\ProgramData\Anaconda3\lib\site-packages\pandas\core\series.py in __getitem__(self, key)
940
941 elif key_is_scalar:
--> 942 return self._get_value(key)
943
944 if is_hashable(key):
C:\ProgramData\Anaconda3\lib\site-packages\pandas\core\series.py in _get_value(self, label, takeable)
1049
1050 # Similar to Index.get_value, but we do not fall back to positional
-> 1051 loc = self.index.get_loc(label)
1052 return self.index._get_values_for_loc(self, loc, label)
1053
C:\ProgramData\Anaconda3\lib\site-packages\pandas\core\indexes\range.py in get_loc(self, key, method, tolerance)
385 return self._range.index(new_key)
386 except ValueError as err:
--> 387 raise KeyError(key) from err
388 raise KeyError(key)
389 return super().get_loc(key, method=method, tolerance=tolerance)
KeyError: -1
对于非整数索引，不会产生歧义,为了进行统一，如果轴索引含有整数，数据选取总会使用标签。为了更准确，请使用loc（标签）或iloc（整数）
(本人实验认证，浮点型也会产生歧义)
算术运算和数据对齐
pandas最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，如果存在不同的索引对，则结果的索引就是该索引对的并集。对于有数据库经验的用户，这就像在索引标签上进行自动外连接
在两个数据相加时自动的数据对齐操作在不重叠的索引处引入了NA值。缺失值会在算术运算过程中传播
对于DataFrame，对齐操作会同时发生在行和列上
In [127]: df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'),
...: .....: index=['Ohio', 'Texas', 'Colorado'])
In [128]: df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
...: .....: index=['Utah', 'Ohio', 'Texas', 'Oregon'])
In [129]: df1
Out[129]:
b c d
Ohio 0.0 1.0 2.0
Texas 3.0 4.0 5.0
Colorado 6.0 7.0 8.0
In [130]: df2
Out[130]:
b d e
Utah 0.0 1.0 2.0
Ohio 3.0 4.0 5.0
Texas 6.0 7.0 8.0
Oregon 9.0 10.0 11.0
In [131]: df1+df2
Out[131]:
b c d e
Colorado NaN NaN NaN NaN
Ohio 3.0 NaN 6.0 NaN
Oregon NaN NaN NaN NaN
Texas 9.0 NaN 12.0 NaN
Utah NaN NaN NaN NaN
在算术方法中填充值
可以使用df1的add方法，传入df2以及一个fill_value参数，这样会把缺失的值默认为0进行累加
DataFrame和Series之间的运算
当我们从arr减去arr[1]，每一行都会执行这个操作。这就叫做广播（broadcasting）
In [136]: arr = np.arange(12.).reshape((3, 4))
In [137]: arr
Out[137]:
array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
In [138]: arr[1]
Out[138]: array([4., 5., 6., 7.])
In [139]: arr-arr[1]
Out[139]:
array([[-4., -4., -4., -4.],
[ 0., 0., 0., 0.],
[ 4., 4., 4., 4.]])
函数应用和映射
NumPy的ufuncs（元素级数组方法）也可用于操作pandas对象
In [190]: frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'),
.....: index=['Utah', 'Ohio', 'Texas', 'Oregon'])
In [191]: frame
Out[191]:
b d e
Utah -0.204708 0.478943 -0.519439
Ohio -0.555730 1.965781 1.393406
Texas 0.092908 0.281746 0.769023
Oregon 1.246435 1.007189 -1.296221
In [192]: np.abs(frame)
Out[192]:
b d e
Utah 0.204708 0.478943 0.519439
Ohio 0.555730 1.965781 1.393406
Texas 0.092908 0.281746 0.769023
Oregon 1.246435 1.007189 1.296221
这里写入代码是为了说明其中(np.random.randn(4, 3)）意思是创造一组4*3的矩阵，里面数据具有标准正态分布
而
In [193]: f = lambda x: x.max() - x.min()
In [194]: frame.apply(f)
Out[194]:
b 1.802165
d 1.684034
e 2.689627
dtype: float64
这里lambda是个匿名函数
In [195]: frame.apply(f, axis='columns')
Out[195]:
Utah 0.998382
Ohio 2.521511
Texas 0.676115
Oregon 2.542656
dtype: float64
这里的axis='columns'是为了告诉计算机我选择行了而非列
排序和排名
根据条件对数据集排序（sorting）也是一种重要的内置运算。要对行或列索引进行排序（按字典顺序），可使用sort_index方法，它将返回一个已排序的新对象
对于DataFrame，则可以根据任意一个轴上的索引进行排序
数据默认是按升序排序的，但也可以降序排序：
frame.sort_index(axis=1, ascending=False)
若要按值对Series进行排序，可使用其sort_values方法,在排序时，任何缺失值默认都会被放到Series的末尾
当排序一个DataFrame时，你可能希望根据一个或多个列中的值进行排序。将一个或多个列的名字传递给sort_values的by选项即可达到该目的
In [163]: frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
In [164]: frame
Out[164]:
b a
0 4 0
1 7 1
2 -3 0
3 2 1
In [165]: frame.sort_values(by='b')
Out[165]:
b a
2 -3 0
3 2 1
0 4 0
1 7 1
带有重复标签的轴索引
对于带有重复值的索引，数据选取的行为将会有些不同。如果某个索引对应多个值，则返回一个Series；而对应单个值的，则返回一个标量值
这样会使代码变复杂，因为索引的输出类型会根据标签是否有重复发生变化。
对DataFrame的行进行索引时也是如此
汇总和计算描述统计
(终于肝到这里，中间没忍住刷了好几次B站)
相关系数与协方差
有些汇总统计（如相关系数和协方差）是通过参数对计算出来的。书中的几个DataFrame，它们的数据来自Yahoo!Finance的股票价格和成交量，使用的是pandas-datareader包（可以用conda或pip安装）
conda install pandas-datareader
书中使用pandas_datareader模块下载了一些股票数据，可惜书中使用的网站是雅虎，雅虎现在已经凉了，所以暂时没有合适的数据，只好硬啃，相关内容都是概率论中各个理论的实现，除了介绍不同的方法以外，并没有新的东西
唯一值、值计数以及成员资格
还有一类方法可以从一维Series的值中抽取信息。
有时，你可能希望得到DataFrame中多个相关列的一张柱状图。
In [20]: data = pd.DataFrame({'Qu1': [1, 3, 4, 3, 4],
...: .....: 'Qu2': [2, 3, 1, 2, 3],
...: .....: 'Qu3': [1, 5, 2, 4, 4]})
In [21]: data
Out[21]:
Qu1 Qu2 Qu3
0 1 2 1
1 3 3 5
2 4 1 2
3 3 2 4
4 4 3 4
In [22]: result = data.apply(pd.value_counts).fillna(0)
In [23]: result
Out[23]:
Qu1 Qu2 Qu3
1 1.0 1.0 1.0
2 0.0 2.0 1.0
3 2.0 2.0 0.0
4 2.0 0.0 2.0
5 0.0 0.0 1.0
这里，结果中的行标签是所有列的唯一值。后面的频率值是每个列中这些值的相应计数
小结
书中内容：
在下一章，我们将讨论用pandas读取（或加载）和写入数据集的工具。
之后，我们将更深入地研究使用pandas进行数据清洗、规整、分析和可视化工具。
通过学习numpy和pandas一些基础应用，了解到Numpy实际上是数值计算的扩展包，它能高效处理N维数组,复杂函数,线性代数.而Panadas是做数据处理，是python的一个数据分析包。同时更深刻了解了一些重要模块的使用，在不同库下调用的区别
明天继续努力！
本文来自博客园，作者：Lugendary，转载请注明原文链接：https://www.cnblogs.com/lugendary/p/16010744.html
