Pyhton - 数据分析
目录
NumPy
NumPy，是Numerical Python 的简称，它是目前Pyhton 数值计算中最为重要的基础包。大多数计算包都提供了基于NumPy 的科学函数功能，将NumPy 的数组对象作为数据交换的通用语。
以下内容将会出现在NumPy 中：
- ndaray，一种高效多维数组，提供了基于数组的便捷算数操作以及灵活的广播功能
- 对所有数据进行快速的矩阵计算，而无须编写循环程序
- 对硬盘中的数组数据进行读写的工具，而对内存映射文件进行操作
- 线性代数、随机数生成以及傅里叶变换功能
- 用于连接NumPy 到C、C++ 和 FORTRAN 语言类库的C语言 API
NumPy 之所以如此重要，其中一个原因就是它的设计对于含有大量数组的数据非常有效。此外，还有如下原因：
-
NumPy 在内部将数据存在连续的内存块上，这与其他的Pyhton 内建数据结构是不同的。NumPy 的算法库是用C语言写的，所以在操作数据内存时，不需要任何类型检查或其他管理操作。NumPy 数组使用的内存量也小于其他Pyhton内建序列。
-
NumPy 可以针对全量数组进行复杂计算而不需要写Pyhton 循环
NumPy ndarry：多维数组对象
NumPy 的核心特征之一就是 N-维数组对象 ———— ndarray。ndarray 是Python 中一个快速、灵活的大型数据集容器。数组允许你使用类似标量的操作语法在整块数据上进行数学计算。
In [2]: import numpy as np
In [3]:
# 生成随机2列3行 数组
In [3]: data = np.random.randn(2,3)
In [4]: data
Out[4]:
array([[-0.61751245, -0.81942049, 0.81130677],
[ 0.06139959, -0.43625469, 1.10106983]])
# 然后给data 加上一个数据操作
In [5]: data * 10
Out[5]:
array([[-6.17512455, -8.1942049 , 8.11306772],
[ 0.6139959 , -4.36254687, 11.0106983 ]])
In [7]: data + data
Out[7]:
array([[-1.23502491, -1.63884098, 1.62261354],
[ 0.12279918, -0.87250937, 2.20213966]])
在第一个数学操作中，所有的元素都同时乘以了10。在第二个数学操作中，数组中的对应元素进行了相加。
一个ndarray 是一个通用的多维同类数据容器，也就是说，它包含的每一个元素均为相同类型。每一个数组都一个shape 属性，用来表征数组每一维度的量；每一个数组都有一个dtype属性，用来描述数组的数据类型
In [8]: data.shape
Out[8]: (2, 3)
In [9]: data.dtype
Out[9]: dtype('float64')
生成 ndarray
生成数组最简单的方式就是使用array函数。array函数接收任意的序列型对象(当然也包括其他的数组)，生成一个新的包含传递数据的NumPy数组。例如，列表的转换就是个好例子：
In [29]: data = [6,7.5,8,0,1]
In [30]: arr1 = np.array(data)
In [31]: arr1
Out[31]: array([6. , 7.5, 8. , 0. , 1. ])
嵌套序列，例如同等长度的列表，将会自动转换成多维数组：
In [35]: In [14]: data2 = [[1,2,3,4],[5,6,7,8]]
In [36]: arr2 = np.array(data2)
In [37]: arr2
Out[37]:
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
因为data2 是一个包含了列表的列表，所以NumPy 数组arr2 形成了二维数组。我们可以通过ndim 和 shape 属性来确认这一点。
In [18]: data2.ndim
Out[18]: 2
In [19]: data2.shape
Out[19]: (2, 4)
除非显示指定，否则np.array 会自动推断生成数组的数据类型。数据类型被存储在一个特殊的元数据dtype中。例如，之前的两个列子：
In [32]: arr1.dtype
Out[32]: dtype('float64')
In [39]: arr2.dtype
Out[39]: dtype('int32')
除了np.array，还有很多其他还函数可以创建新数组，。例如，给定长度及形状之后，zeros 可以一次性创造全0 数组，ones 可以一次性创造全是1 数组。empty 则可以创建一个没有初始化值得数组。想要创建高维数组，则需要为shape 传递一个元组：
In [21]: np.zeros(10)
Out[21]: array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
In [22]: np.zeros((3,6))
Out[22]:
array([[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.]])
In [23]: np.empty((2,3,2))
Out[23]:
array([[[0., 0.],
[0., 0.],
[0., 0.]],
[[0., 0.],
[0., 0.],
[0., 0.]]])
NumPy 数组运算
数组之所以重要是因为它允许你进行批量操作而无须任何for循环。NumPy 用户称这种特性为向量化。任何在两个等尺寸数组之间的算术操作都对应用了逐元素操作的方式：
In [35]: arr = np.array([[1.,2.,3.],[4.,5.,6.]])
In [36]: arr
Out[36]:
array([[1., 2., 3.],
[4., 5., 6.]])
In [37]: arr * arr
Out[37]:
array([[ 1., 4., 9.],
[16., 25., 36.]])
In [38]: arr - arr
Out[38]:
array([[0., 0., 0.],
[0., 0., 0.]])
# 带有标量计算的算术操作，会把计算参数传递给数组的每一个元素：
In [39]: 1 / arr
Out[39]:
array([[1. , 0.5 , 0.33333333],
[0.25 , 0.2 , 0.16666667]])
In [40]: arr ** 0.5
Out[40]:
array([[1. , 1.41421356, 1.73205081],
[2. , 2.23606798, 2.44948974]])
In [41]: arr2 = np.array([[0.,4.,1.],[7.,2.,12.]])
# 同尺寸数据之间的比较，会产生一个布尔值的数组：
In [43]: arr2 > arr
Out[43]:
array([[False, True, False],
[ True, False, True]])
不同尺寸的数组间的操作，将会用到广播特性。
基础索引与切片
pandas
pandas 所包含的数据结构和数据处理工具的设计使得在Python中进行数据清洗和分析非常快捷。panads 经常是和其他数值计算工具，比如NumPy 和 SciPy，以及数据可视化工具比如matplotlib一起使用的。pandas 支持大部分 NumPy语言风格的数组计算，尤其是数组函数以及没有for 循环的各种数据处理。
尽管pandas 采用了很多NumPy 的代码风格，但最大的不同在于pandas是用来处理表格型或异质型数据的。而Numpy则相反，它更适合处理同质型的数值类数组数据。
为了入门pandas ，需要熟悉两个常用的工具数据结构：Series 和 DataFrame。尽管它们并不能解决所有的问题，但它们为大多数应用提供了一个有效、易用的基础。
Series
Series 是一种一维的数组型对象，它包含了一个值序列(与NumPy中的类型相似)，并且包含了数据标签，成为索引(index)。
In [3]: import pandas as pd
In [4]: obj = pd.Series([4,7,-5, 3])
In [5]: obj
Out[5]:
0 4
1 7
2 -5
3 3
dtype: int64
# 获取值
In [6]: obj.values
Out[6]: array([ 4, 7, -5, 3], dtype=int64)
# 获取索引
In [7]: obj.index
Out[7]: RangeIndex(start=0, stop=4, step=1)
# 通常需要创建一个索引序列，用标签标识每个数据点
In [8]: obj2 = pd.Series([4,7,-5,3], index=['d','b','a','c'])
In [9]: obj2
Out[9]:
d 4
b 7
a -5
c 3
dtype: int64
In [10]: obj2.index
Out[10]: Index(['d', 'b', 'a', 'c'], dtype='object')
# 与NumPy 的数组相比，可以在从数据中选择数据的时候使用标签来进行索引：
In [11]: obj2['a']
Out[11]: -5
In [12]: obj2['d'] = 6
In [14]: obj2[['a','c','d']]
Out[14]:
a -5
c 3
d 6
dtype: int64
'''
上面的例子中, ['a','c','d'] 包含的不是数字而是字符串，作为索引列表
'''
# 数学运算
In [9]: obj2[obj2 > 2]
Out[9]:
d 6
b 7
c 3
dtype: int64
In [10]: obj2 * 2
Out[10]:
d 12
b 14
a -10
c 6
dtype: int64
In [5]: np.exp(obj2)
Out[5]:
d 403.428793 # 自然数e 的 6 次幂
b 1096.633158
a 0.006738
c 20.085537 # 自然数 e 的 3 次幂
dtype: float64
# 从另一个角度考虑Series ，可以认为它是一个长度固定且有序的字典，因为它将索引值和数据值按位置配对。
# 在可能会使用字典的上下文中，也可以使用Series：
In [7]: 'b' in obj2
Out[7]: True
In [8]: 'f' in obj2
Out[8]: False
# 如果已经有数据包含在Python字典中，可以使用字典生成一个Series：
In [9]: sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
In [10]: obj3 = pd.Series(sdata)
In [11]: obj3
Out[11]:
Ohio 35000
Texas 71000
Oregon 16000
Utah 5000
dtype: int64
# 当把字典传递给Series的构造函数时，产生的Series 的索引将是排序好的字典健，可以
# 将字典健按照你所想要的顺序传递给函数，从而使生成的Series 的索引顺序符合你的预期：
In [12]: states = ['California', 'Ohio', 'Oregon', 'Texas']
In [13]: obj4 = pd.Series(sdata,index=states)
In [15]: obj4
Out[15]:
California NaN # California 没有在字典的健中，NaN是pandas 表示缺失值或NA的方式
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64
# states 中没有 'Utah' 所以它被排除在结果对象外
# isnull 和 notnull 函数检查缺失数据：
In [16]: pd.isnull(obj4)
Out[16]:
California True
Ohio False
Oregon False
Texas False
dtype: bool
In [17]: pd.notnull(obj4)
Out[17]:
California False
Ohio True
Oregon True
Texas True
dtype: bool
# isnull 和 notnull 函数 也是Series 实例的方法
In [18]: obj4.isnull()
Out[18]:
California True
Ohio False
Oregon False
Texas False
dtype: bool
In [19]: obj4.notnull()
Out[19]:
California False
Ohio True
Oregon True
Texas True
dtype: bool
# Series 实例相加，自动对齐索引
In [20]: obj3
Out[20]:
Ohio 35000
Texas 71000
Oregon 16000
Utah 5000
dtype: int64
In [21]: obj4
Out[21]:
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64
In [22]: obj3 + obj4
Out[22]:
California NaN
Ohio 70000.0
Oregon 32000.0
Texas 142000.0
Utah NaN
dtype: float64
Series 对象自身和其索引都有name属性
Series 的索引可以通过按位置赋值的方式进行改变：
In [30]: obj
Out[30]:
0 4
1 7
2 -5
3 3
dtype: int64
In [32]: obj.index = ['Bob','Steve','Jeff','Ryan']
In [33]: obj
Out[33]:
Bob 4
Steve 7
Jeff -5
Ryan 3
dtype: int64
DataFrame
DataFrame 表示的是矩阵的数据表，它包含已排序的列集合，每一列可以是不同的值类型(数值，字符串，布尔值等)。DataFrame既有行索引也有列索引，它可以被视为一个共享相同索引的Sreies的字典。在DataFrame中数据被存储为一个以上的二维块，而不是列表、字典或其他一维数组的集合。
In [36]: 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 [37]: data
Out[37]:
{'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 [38]: frame = pd.DataFrame(data)
# 产生的DataFrame 会自动为Series分配索引，并且列会按照排序的顺序排列
In [39]: frame
Out[39]:
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
# head 方法将会只选出头部五行：
In [40]: frame.head()
Out[40]:
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
# 如果指定了列的顺序，DataFrame 的列将会按照指定顺序排列
In [42]: pd.DataFrame(data,columns=['year','state','pop'])
Out[42]:
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 [43]: frame2 = pd.DataFrame(data,columns=['year','state','pop','debt'],index=['one','two','three','four','five','six
...: '])
In [44]: frame2
Out[44]:
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 [45]: frame2.columns
Out[45]: Index(['year', 'state', 'pop', 'debt'], dtype='object')
# DataFrame 中的一列，可以按字典型标记或属性那样检索为 Series
In [46]: frame2['state']
Out[46]:
one Ohio
two Ohio
three Ohio
four Nevada
five Nevada
six Nevada
Name: state, dtype: object
In [48]: frame2.year
Out[48]:
one 2000
two 2001
three 2002
four 2001
five 2002
six 2003
Name: year, dtype: int64
# 行也可以通过位置或特殊属性loc进行选取
In [50]: frame2.loc['one']
Out[50]:
year 2000
state Ohio
pop 1.5
debt NaN
Name: one, dtype: object
# 列引用是可以修改的，如 为空的 'debt'列可以赋值为标量值或值数组：
In [52]: frame2['debt'] = 16.5
In [53]: frame2
Out[53]:
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 [54]: frame2['debt'] = np.arange(6.)
In [55]: frame2
Out[55]:
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
# 如果被赋值的列不存在，则会生成一个新的列
# 增加一列，这一列是布尔值，判断条件是state 列是否为'Ohio'
In [60]: frame2['eastern'] = frame2.state == 'Ohio'
In [61]: frame2
Out[61]:
year state pop debt eastern
one 2000 Ohio 1.5 NaN True
two 2001 Ohio 1.7 -1.2 True
three 2002 Ohio 3.6 NaN True
four 2001 Nevada 2.4 -1.5 False
five 2002 Nevada 2.9 -1.7 False
six 2003 Nevada 3.2 NaN False
# del 可以删除一列
In [63]: del frame2['eastern']
In [65]: frame2
Out[65]:
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 -1.2
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 -1.5
five 2002 Nevada 2.9 -1.7
six 2003 Nevada 3.2 NaN
In [66]: frame2.columns
Out[66]: Index(['year', 'state', 'pop', 'debt'], dtype='object')
另外一种常用的数据形式是包含字典的嵌套字典
In [67]: pop = {'Vevdad':{2001:2.4,2002:2.9},'Ohio':{2000:1.5,2001:1.7,2002:3.6
...: }}
In [68]: frame3 = pd.DataFrame(pop)
# 外部字典的健作为列，嵌套字典的健作为行索引
In [69]: frame3
Out[69]:
Vevdad Ohio
2001 2.4 1.7
2002 2.9 3.6
2000 NaN 1.5
# 可以使用类似Numpy的语法对DataFrame 进行转置操作(调换行和列 )
In [70]: frame3.T
Out[70]:
2001 2002 2000
Vevdad 2.4 2.9 NaN
Ohio 1.7 3.6 1.5
# 显示指明索引，内部字典的健将不再作为索引使用
In [72]: pd.DataFrame(pop,index=[2001,2002,2003])
Out[72]:
Vevdad Ohio
2001 2.4 1.7
2002 2.9 3.6
2003 NaN NaN
In [79]: frame3
Out[79]:
Vevdad Ohio
2001 2.4 1.7
2002 2.9 3.6
2000 NaN 1.5
# 包含Series的字典也可以用于构造DataFrame：
In [77]: pdata = {'Ohio':frame3['Ohio'][:-1],'Vevdad':frame3['Vevdad'][:2]}
In [78]: pd.DataFrame(pdata)
Out[78]:
Ohio Vevdad
2001 1.7 2.4
2002 3.6 2.9
# 如果DataFrame 的索引和列拥有name属性，则这些name属性也会被显示
In [82]: frame3.index.name = 'year'
In [83]: frame3.columns.name = 'state'
In [84]: frame3
Out[84]:
state Vevdad Ohio
year
2001 2.4 1.7
2002 2.9 3.6
2000 NaN 1.5
# 和Series类似，DataFrame的values属性会将包含在DataFrame中的数据以二维ndarray的形式返回：
In [85]: frame3.values
...:
Out[85]:
array([[2.4, 1.7],
[2.9, 3.6],
[nan, 1.5]])
# 如果DataFrame 的列是不同的dtypes，则values的dtype会自动选择适合所有列的类型：
In [86]: frame2
Out[86]:
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 -1.2
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 -1.5
five 2002 Nevada 2.9 -1.7
six 2003 Nevada 3.2 NaN
In [87]: frame2.values
Out[87]:
array([[2000, 'Ohio', 1.5, nan],
[2001, 'Ohio', 1.7, -1.2],
[2002, 'Ohio', 3.6, nan],
[2001, 'Nevada', 2.4, -1.5],
[2002, 'Nevada', 2.9, -1.7],
[2003, 'Nevada', 3.2, nan]], dtype=object)
写入Excel
将数据写入到不同的sheet(方法一):
data = [('张三', 28, '深圳市福田区'), ('李四', 18, '深圳市南山区'), ('王五', 20, '深圳市宝安区')]
data2 = [('张三', 28, '深圳市福田区'), ('李四', 18, '深圳市南山区'), ('王五', 20, '深圳市宝安区')]
title = ['name','age','address']
df1 = pd.DataFrame(data)
df2 = pd.DataFrame(data2)
w = pd.ExcelWriter(r'test_01\result.xlsx')
df1.to_excel(w,sheet_name='sheet1', header=title, index=False)
df1.to_excel(w,sheet_name='sheet2', header=title, index=False)
w._save()
w.close()
将数据写入到不同的sheet(方法二,推荐写法):
data = [('张三', 28, '深圳市福田区'), ('李四', 18, '深圳市南山区'), ('王五', 20, '深圳市宝安区')]
data2 = [('张三', 28, '深圳市福田区'), ('李四', 18, '深圳市南山区'), ('王五', 20, '深圳市宝安区')]
title = ['name','age','address']
df1 = pd.DataFrame(data)
df2 = pd.DataFrame(data2)
with pd.ExcelWriter(r'test_01\result.xlsx') as w:
df1.to_excel(w, sheet_name='sheet1', header= title, index=False)
df2.to_excel(w, sheet_name='sheet2', header=title, index=False)
# 根据数据格式的不同也可以用以下方法
data = {'name': ['张三', '李四', '王五'], 'age': [28, 18, 20], 'address': ['深圳市福田区', '深圳市南山区', '深圳市宝安区']}
data2 = {'name': ['张三', '李四', '王五'], 'age': [28, 18, 30], 'address': ['深圳市福田区', '深圳市南山区', '深圳市宝安区']}
df1 = pd.DataFrame(data)
df2 = pd.DataFrame(data2)
with pd.ExcelWriter(r'test_01\result.xlsx') as w:
df1.to_excel(w, sheet_name='sheet1', index=False)
df2.to_excel(w, sheet_name='sheet2', index=False)
索引对象
pandas 中的索引对象是用于存储轴标签和其他元数据的(例如轴名称或标签)。在构造Series 或 DataFrame 时，你所使用的任意数组或标签序列都可以在内部转换为索引对象。
In [46]: import pandas as pd
In [47]: obj = pd.Series(range(3),index=['a','b','c'])
In [48]: obj
Out[48]:
a 0
b 1
c 2
dtype: int64
In [49]: index = obj.index
In [50]: index
Out[50]: Index(['a', 'b', 'c'], dtype='object')
In [51]: index[1:]
Out[51]: Index(['b', 'c'], dtype='object')
# 索引对象是不可变的，因此用户是无法修改索引对象的：
### 索引对象
pandas 中的索引对象是用于存储轴标签和其他元数据的(例如轴名称或标签)。在构造Series 或 DataFrame 时，你所使用的任意数组或标签序列都可以在内部转换为索引对象。
```python
In [46]: import pandas as pd
In [47]: obj = pd.Series(range(3),index=['a','b','c'])
In [48]: obj
Out[48]:
a 0
b 1
c 2
dtype: int64
In [49]: index = obj.index
In [50]: index
Out[50]: Index(['a', 'b', 'c'], dtype='object')
In [51]: index[1:]
Out[51]: Index(['b', 'c'], dtype='object')
# 不变性使得在多种数据结构中分享索引对象更为安全：
In [55]: labels = pd.Index(np.arange(3))
In [56]: labels
Out[56]: Int64Index([0, 1, 2], dtype='int64')
In [57]: obj2 = pd.Series([1.5,-2.5,0],index=labels)
In [58]: obj2
Out[58]:
0 1.5
1 -2.5
2 0.0
dtype: float64
In [59]: obj2.index is labels
Out[59]: True
一些用户并不经常利用索引对象提供的功能，但是因为一些操作会产生包含索引化的结果，理解索引如何工作还是很重要的。
除了类似数组，索引对象也像一个固定大小的集合：
In [68]: frame3
Out[68]:
Vevdad Ohio
2001 2.4 1.7
2002 2.9 3.6
2000 NaN 1.5
In [69]: frame3.columns
Out[69]: Index(['Vevdad', 'Ohio'], dtype='object')
In [70]: 'Ohio' in frame3.columns
Out[70]: True
In [71]: 2003 in frame3.index
Out[71]: False
与 Python 集合不同，pandas 索引对象可以包含重复标签
In [73]: dup_labels = pd.Index(['foo','foo','bar', 'bar'])
In [74]: dup_labels
Out[74]: Index(['foo', 'foo', 'bar', 'bar'], dtype='object')
根据重复标签进行筛选，会选取所有重复标签对应的数据
每个索引都有一些集合逻辑的方法和属性，这些方法和属性解决了关于它所包含的数据恶的其他常见问题。
基本功能
重建索引
reindex 是 pandas 独享的重要方法，该方法用于创建一个符合新索引的新对象。考虑下面列子：
In [75]: obj = pd.Series([4.5,7.2,-5.3,3.6], index=['d','b','a','c'])
In [76]: obj
Out[76]:
d 4.5
b 7.2
a -5.3
c 3.6
dtype: float64
# Series 调用 reindex 方法时，会将数据按照新的索引进行排列，如果某个索引值之前并不存在，则会引入缺失值。
In [77]: obj2 = obj.reindex(['a','b','c','d','e'])
In [78]: obj2
Out[78]:
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
dtype: float64
# 对于顺序数据，比如时间序列，在重建索引时可能会需要进行插值或填值。method 可选参数允许我们使用诸如ffill等方法在重建索引时插值，ffill方法将值前向填充：
In [79]: obj3 = pd.Series(['bule','purple','yellow'],index=[0,2,4])
In [80]: obj3
Out[80]:
0 bule
2 purple
4 yellow
dtype: object
In [82]: obj3.reindex(range(6),method='ffill')
Out[82]:
0 bule
1 bule
2 purple
3 purple
4 yellow
5 yellow
dtype: object
# 在DataFrame 中，reindex 可以改变行索引、列索引，也可以同时改变二者。当仅传入一个序列时，结果中得行会重建索引：
In [7]: frame = pd.DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['Ohio','Texas','California'])
In [8]: frame
Out[8]:
Ohio Texas California
a 0 1 2
b 3 4 5
c 6 7 8
In [9]: np.arange(9)
Out[9]: array([0, 1, 2, 3, 4, 5, 6, 7, 8])
In [10]: frame2 = frame.reindex(['a','b','c','d'])
In [11]: frame2
Out[11]:
Ohio Texas California
a 0.0 1.0 2.0
b 3.0 4.0 5.0
c 6.0 7.0 8.0
d NaN NaN NaN
# 列可以使用columns 关键字重建索引：
In [12]: states = ['Texas','Utah','California']
In [13]: frame.reindex(columns=states)
Out[13]:
Texas Utah California
a 1 NaN 2
b 4 NaN 5
c 7 NaN 8
In [14]:
轴向上删除条目
如果你已经拥有索引数组或不含条目的列表，在轴向上删除一个或更多的条目就非常容易，但这样需要一些数据操作和集合逻辑，drop方法会返回一个含有指示值或轴向上删除值得新对象：
In [23]: obj = pd.Series(np.arange(5.),index=['a','b','c','d','e'])
In [24]: obj
Out[24]:
a 0.0
b 1.0
c 2.0
d 3.0
e 4.0
dtype: float64
In [25]: new_obj = obj.drop('c')
In [26]: new_obj
Out[26]:
a 0.0
b 1.0
d 3.0
e 4.0
dtype: float64
In [27]: obj.drop(['d','c'])
Out[27]:
a 0.0
b 1.0
e 4.0
dtype: float64
在DataFrame 中，索引值可以从轴向上删除。为了表明这个特性，我们首先创建一个示例DataFrame：
In [28]: data = pd.DataFrame(np.arange(16).reshape((4,4)),index=['Ohio','Colorado','Utah','New York'],columns=['one','t
...: wo','three','four'])
In [29]: data
Out[29]:
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
# 在调用 drop 时使用标签序列会根据行标签删除值(轴0)：
In [31]: data.drop(['Colorado','Ohio'])
Out[31]:
one two three four
Utah 8 9 10 11
New York 12 13 14 15
# 你可以通过传递 axis=1，axis='columns' 来从列中删除值：
In [32]: data.drop('two',axis=1)
Out[32]:
one three four
Ohio 0 2 3
Colorado 4 6 7
Utah 8 10 11
New York 12 14 15
In [33]: data.drop(['two','four'],axis='columns')
Out[33]:
one three
Ohio 0 2
Colorado 4 6
Utah 8 10
New York 12 14
读取excel
import pandas as pd
work_book = pd.ExcelFile('test.xlsx')
sheet_names = work_book.sheet_names # 获取所有sheet 名称
print(sheet_names)
for sheet_name in sheet_names:
df = pd.read_excel(work_book, sheet_name=sheet_name)
print(df)
https://www.zhangshengrong.com/p/noXQbAvG1G/
https://blog.csdn.net/weixin_43092663/article/details/124155354
https://blog.csdn.net/u010799534/article/details/125429064
https://blog.csdn.net/sinat_41858359/article/details/136361515
https://www.zhihu.com/question/506726329/answer/3413177110
https://blog.csdn.net/Gaafung/article/details/116562988
https://blog.csdn.net/chenzhjlf/article/details/136843485
本文来自博客园，作者：chuangzhou，转载请注明原文链接：https://www.cnblogs.com/czzz/p/17015806.html
