Author: 楚格
2018-11-28 20:21:18
IDE： Pycharm2018.03 Anaconda 3.5.1 Python 3.7
KeyWord : Pandas
Explain: 更新中
---------------------------------------------------------------------------
--------
1 # -*- coding: utf-8 -*-
2 #---------------------------------
3 '''
4 # Author : chu ge
5 # Function:
6 #
7 '''
8 #---------------------------------
9 '''
10 --------------------------------
11 导入模块
12 1.系统库
13 2.第三方库
14 3.相关定义库
15 --------------------------------
16 '''
17 # 1.系统库
18 import sys
19 import os
20 # 2.第三方库
21 import pandas
22 import numpy as np
23 import pandas as pd
24 from numpy import nan as NA
25 from pandas import Series, DataFrame, Index, MultiIndex
26 '''
27 ============================================================================
28 》》》》》》》》》》》》》》》》》》》》》》》》
29 Pandas
30 ----------------------------------------------
31 简介：Pandas是python的一个数据分析包，目前由专注于Python数据包开发的PyData开发team继续开发和维护，属于PyData项目的
32 一部分。Pandas最初被作为金融数据分析工具而开发出来，因此，pandas为时间序列分析提供了很好的支持。
33
34 ----------------------------------------------
35 基本功能
36 • 开发pandas时提出的需求
37 • 具备按轴自动或显式数据对齐功能的数据结构
38 • 集成时间序列功能
39 • 既能处理时间序列数据也能处理非时间序列数据的数据结构
40 • 数学运算和约简（比如对某个轴求和）可以根据不同的元数据（轴编号）执行
41 • 灵活处理缺失数据
42 • 合并及其他出现在常见数据库（例如基于SQL的）中的关系型运算
43
44
45 Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成。
46 • Series的字符串表现形式为：索引在左边，值在右边。
47 • 创建
48 • 读写
49 • 运算
50
51 数据结构 DataFrame
52 • DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。
53 • DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。
54 • 创建
55 • 读写
56
57 可以输入给DataFrame构造器的数据
58 二维ndarray 数据矩阵，还可以传入行标和列标。
59 由数组、列表或元组组成的字典 每个序列会变成DataFrame的一列，所有序列的长度必须相同。
60 NumPy的结构化/记录数组 类似于“由数组组成的字典”
61 由Series组成的字典 每个Series会组成一列。如果没有显示指定索引，则各Series的索引会被合并成结果的行索引。
62 由字典组成的字典 各内层字典会成为一列。键会被合并成结果的行索引，跟“由Series组成的字典”的情况一样。
63 字典或Series的列表 各项将会成为DataFrame的一行。字典键或Series索引的并集将会成为DataFrame的列标。
64 由列表或元组组成的列表 类似于“二维ndarray”
65 另一个DataFrame 该DataFrame的索引将会被沿用，除非显示指定了其他索引。
66 NumPy的MaskedArray 类似于“二维ndarray”的情况，只是掩码值在结果DataFrame会变成NA/缺失值。
67
68
69 数据结构 索引对象
70 • pandas的索引对象负责管理轴标签和其他元数据（比如轴名称等）。构建Series或DataFrame时，
71 所用到的任何数组或其他序列的标签都会被转换成一个Index。
72 • Index对象是不可修改的（immutable），因此用户不能对其进行修改。不可修改性非常重要，
73 因为这样才能使Index对象在多个数据结构之间安全共享。
74
75 pandas中主要的index对象
76 index 最泛化的Index对象，将轴标签为一个由Python对象组成的NumPy数组。
77 Int64Index 针对整数的特殊Index
78 MultiIndex “层次化”索引对象，表示单个轴上的多层索引。可以看做由园数组组成的数 组。
79 DatetimeIndex 存储纳秒级时间戳
80 PeriodIndex 针对Period数据的特殊Index
81
82 Index的方法和属性 I
83 append append 连接另一个Index对象，产生一个新的Index。
84 diff 计算差集，并得到一个Index。
85 intersection 计算交集
86 union 计算并集
87 isin 计算一个指示各值是否包含在参数集合中的布尔型数组
88 delete 删除索引i处的元素，并得到新的Index
89
90 Index的方法和属性 II
91 drop 删除传入的值，并得到新的索引。
92 insert 将元素插入到索引i处，并得到新的Index。
93 is_monotonic 当各元素均大于等于前一个元素时，返回True。
94 is_unique 当Index没有重复值时，返回True。
95 unique 计算Index中唯一值得数组
96
97
98
99 基本功能 重新索引
100 • 创建一个适应新索引的新对象，该Series的reindex将会根据新索引进行重排。如果某个索引值当前不存在，就引入缺失值
101 • 对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理。 method选项即可达到此目的。
102
103 reindex函数的参数
104 index 用作索引的新序列。既可以是Index实例，也可以是其它序列型的Python数据结构。
105 Index会被完全使用，就像没有任何复制一样。
106 method 插值填充方式，ffill或bfill。
107 fill_value 在重新索引过程中，需要引入缺失值时使用的替代值。
108 limit 前向或后向填充时的最大填充量
109 level 在MultiIndex的指定级别上匹配简单索引，否则选取其子集。
110 copy 默认为True，无论如何都复制。如果为False，则新旧相等就不复制。
111
112
113 基本功能 丢弃指定轴上的项
114 • 丢弃某条轴上的一个或多个项很简单，只要有一个索引数组或列表即可。由于需要执行一些数据整理和集合逻辑，
115 所以drop方法返回的是一个在指定轴上删除了指定值的新对象
116
117
118 基本功能 索引、选取和过滤
119 • Series索引（obj[...]）的工作方式类似于NumPy数组的索引，只不过Series的索引值不只是整数。
120 • 利用标签的切片运算与普通的Python切片运算不同，其末端是包含的（inclusive）。
121 • 对DataFrame进行索引其实就是获取一个或多个列
122 • 为了在DataFrame的行上进行标签索引，引入了专门的索引字段ix。
123
124
125 基本功能 索引、选取和过滤
126 • DataFrame的索引选项
127 obj[val] 选取DataFrame的单个列或一组列。在一些特殊情况下会比较便利：
128 布尔型数组（过滤行）、切片（行切片）、布尔型DataFrame（根据条件设置值）。
129 obj.ix[val] 选取DataFrame的单个行或一组行
130 obj.ix[:, val] 选取单个列或列子集
131 obj.ix[val1, val] 同时选取行或列
132 reindex方法 将一个或多个轴匹配到新索引
133 xs方法 根据标签选取单行或单列，并返回一个Series。
134 icol、irow方法 根据整数位置选取单行或单列，并返回一个Series。
135 get_value、set_value方法 根据行标签或列标签选取单个值
136
137
138 基本功能 算术运算和数据对齐
139 • 对不同的索引对象进行算术运算
140 • 自动数据对齐在不重叠的索引处引入了NA值，缺失值会在算术运算过程中传播。
141 • 对于DataFrame，对齐操作会同时发生在行和列上。
142 • fill_value参数
143 • DataFrame和Series之间的运算
144
145
146 基本功能 函数应用和映射
147 • numpy的ufuncs（元素级数组方法）
148 • DataFrame的apply方法
149 • 对象的applymap方法（因为Series有一个应用于元素级的map方法）
150
151
152 基本功能 排序和排名
153 • 对行或列索引进行排序
154 • 对于DataFrame，根据任意一个轴上的索引进行排序
155 • 可以指定升序降序
156 • 按值排序
157 • 对于DataFrame，可以指定按值排序的列
158 • rank函数
159
160 基本功能 带有重复值的索引
161 • 对于重复索引，返回Series，对应单个值的索引则返回标量
162
163
164 汇总和计算描述统计
165 • 常用方法选项
166 axis 指定轴，DataFrame的行用0，列用1。
167 skipna 排除缺失值，默认值为True。
168 level 如果轴是层次化索引的（即MultiIndex），则根据level选取分组
169
170 汇总和计算描述统计
171 • 常用描述和汇总统计函数 I
172 count 非NA值的数量
173 describe 针对Series或各DataFrame列计算汇总统计
174 min, max 计算最小值和最大值
175 argmin, argmax 计算能够获取到最小值和最大值的索引位置（整数）
176 idxmin, idxmax 计算能够获取到最小值和最大值的索引值
177 sum 值的总和
178 mean 值的平均数
179 median 值的算术中位数
180 mad 根据平均值计算平均绝对离差
181 常用描述和汇总统计函数 II
182 var 样本值的方差
183 std 样本值的标准差
184 skew 样本值的偏度（三阶矩）
185 kurt 样本值的偏度（四阶矩）
186 cumsum 样本值的累计和
187 cummin, cummax 样本值的累计最大值和累计最小值
188 cumprod 样本值的累计积
189 diff 计算一阶差分
190 pct_change 计算百分数变化
191
192 • 数值型和非数值型的区别
193 • NA值被自动排查，除非通过skipna选项
194
195
196
197 汇总和计算描述统计 相关系数与协方差
198 • 相关系数：相关系数是用以反映变量之间相关关系密切程度的统计指标
199 • 协方差：从直观上来看，协方差表示的是两个变量总体误差的期望。如果两个变量的变化趋势一致，也就是说如果其中
200 一个大于自身的期望值时另外一个也大于自身的期望值，那么两个变量之间的协方差就是正值；如果两个变量的变化趋势
201 相反，即其中一个变量大于自身的期望值时另外一个却小于自身的期望值，那么两个变量之间的协方差就是负值。
202
203
204 汇总和计算描述统计 唯一值以及成员资格
205 • 常用方法
206 is_in 计算一个表示“Series各值是否包含于传入的值序列中”的布尔型数组
207 unique 计算Series中的唯一值数组，按发现的顺序返回。
208 value_counts 返回一个Series，其索引为唯一值，其值为频率，按计数值降序排列。
209
210
211 处理缺失数据
212 • NA处理方法
213 • NaN（Not a Number）表示浮点数和非浮点数组中的缺失数据
214 • None也被当作NA处理
215
216 NA处理方法
217 dropna 根据各标签的值中是否存在缺少数据对轴
218 fillba 样本值的标准差
219 isnull 样本值的偏度（三阶矩）
220 notnull
221
222 处理缺失数据 滤除缺失数据
223 • dropna
224 • 布尔索引
225 • DatFrame默认丢弃任何含有缺失值的行
226 • how参数控制行为，axis参数选择轴，thresh参数控制留下的数量
227 • fillna
228 • inplace参数控制返回新对象还是就地修改
229
230
231 层次化索引
232 • 使你能在一个轴上拥有多个（两个以上）索引级别。抽象的说，它使你能以低纬度形式处理高维度数据。
233 • 通过stack与unstack变换DataFrame
234
235
236 层次化索引 重新分级顺序
237 • 索引交换
238 • 索引重新排序
239
240
241 层次化索引 根据级别汇总统计
242 • 指定索引级别和轴
243
244
245 层次化索引 使用DataFrame的列
246 • 将指定列变为索引
247 • 移除或保留对象
248 • reset_index恢复
249
250 其它话题 整数索引
251 • 歧义的产生
252 • 可靠的，不考虑索引类型的，基于位置的索引。
253
254
255 其它话题 面板(Pannel)数据
256 • 通过三维ndarray创建pannel对象
257 • 通过ix[...]选取需要的数据
258 • 访问顺序：item -> major -> minor
259 • 通过stack展现面板数据
260 ----------------------------------------------
261
262 ============================================================================
263 '''
264
265 '''
266 # ============================================================================
267 # Function:
268 # Explain : 输入参数
269 # : 输出参数
270 # ============================================================================
271 '''
272
273 # ============================================================================
274 '''
275 # ============================================================================
276 # 测试专用
277 # ============================================================================
278 '''
279 if __name__ == "__main__":
280
281 print("123")
282 # try:
283 # print("\n 用数组生成Series:")
284 # obj = Series([4, 7, -5, 2])
285 # print('>>>1\n', obj)
286 # print('>>>2\n', obj.values)
287 # print('>>>3\n', obj.index)
288 # print('\n指定Series的index')
289 # obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
290 # print('>>>4\n', obj2)
291 # print('>>>5\n', obj2.index)
292 # print('>>>6\n',obj2['a'] )
293 # obj2['d'] = 6
294 # print('>>>7\n', obj2[['c', 'a', 'd']])
295 # print('>>>8\n', obj2[ obj2 > 3]) # 找出大于0的元素
296 # print('>>>9.0\n', 'b' in obj2) # 判断索引是否存在
297 # print('>>>9.1\n', 'e' in obj2)
298 # print("\n使用字典生成Series")
299 # sdata = {'Ohio': 45000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
300 # obj3 = Series(sdata)
301 # print('>>>10\n', obj3)
302 # print("\n使用字典生成Series，并额外指定index，不匹配部分为NaN")
303 # states = ['California', 'Ohio', 'Oregon', 'Texas']
304 # obj4 = Series(sdata, index=states)
305 # print('>>>11\n', obj4)
306 # print("\n Series相加，相同索引部分相加")
307 # print('>>>12\n', obj3 + obj4)
308 # print("指定Series及其索引的名字")
309 # obj4.name = 'population'
310 # obj4.index.name = 'state'
311 # print('>>>13\n', obj4)
312 # print("替换index")
313 # obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
314 # print('>>>14\n', obj)
315 #
316 # except Exception:
317 # print("出问题！！！")
318
319 # try:
320 # print("\n 用字典生成DataFrame，key为列的名字")
321 # data = {'state': [' Ohio', ' Ohio', ' Ohio', ' Nevada', ' Nevada'],
322 # 'year': [2000, 2001, 2002, 2001, 2002],
323 # 'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
324 # print('>>>1\n', DataFrame(data))
325 # print('>>>2\n', DataFrame(data, columns=['year', 'state', 'pop']) ) # 指定列顺序
326 # print("\n 指定索引，在列中指定不存在的列，默认数据用NaN")
327 # frame2 = DataFrame(data,
328 # columns=['year', 'state', 'pop', 'debt'],
329 # index=['one', 'two', 'three', 'four', 'five'])
330 # print('>>>3\n',frame2 )
331 # print('>>>4\n', frame2['state'])
332 # print('>>>5\n', frame2.year)
333 # # print('>>>6\n', frame2['three'])
334 # frame2['debt'] = 16.5 # 修改一整列
335 # print('>>>7.0\n', frame2)
336 # frame2.debt = np.arange(5) # 用numpy数组修改元素
337 # print('>>>7.1\n', frame2)
338 # print("\n 用Series指定要修改的索引及其对应的值，没有指定的默认数据用NaN")
339 # val = Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
340 # frame2['debt'] = val
341 # print('>>>8\n', frame2)
342 # print("\n 赋值给新列")
343 # frame2['eastern'] = (frame2.state == 'Ohio') # 如果state等于Ohio为True
344 # print('>>>9\n', frame2)
345 # print('>>>10\n', frame2.columns)
346 # print("\n DataFrame转置")
347 # pop = {'Nevada': {2001: 2.4, 2002: 2.9},
348 # 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
349 # frame3 = DataFrame(pop)
350 # print('>>>11\n', frame3)
351 # print('>>>12\n', frame3.T)
352 # print("\n指定索引顺序，以及使用切片初始化数据")
353 # # print('>>>13\n', DataFrame(pop, index=[2001, 2002, 2003]))
354 # pdata = {'Ohio': frame3['Ohio'][:-1], 'Nevada': frame3['Nevada'][:2]}
355 # print('>>>14\n', DataFrame(pdata))
356 # print("指定索引和列的名称")
357 # frame3.index.name = 'year'
358 # frame3.columns.name = 'state'
359 # print('>>>15\n', frame3)
360 # print('>>>16\n', frame3.values)
361 # print('>>>17\n', frame2.values)
362 # except Exception:
363 # print("出问题！！！")
364
365 # try:
366 # print("\n 获取index")
367 # obj = Series(range(3), index=['a', 'b', 'c'])
368 # index = obj.index
369 # print('>>>1\n', index[:])
370 # try:
371 # index[1] = '1' # index对象read only
372 # except:
373 # print('\n>>>',sys.exc_info()[0])
374 # print("error")
375 # print("\n 使用Index对象")
376 # index = Index(np.arange(3))
377 # obj2 = Series([1.5, -2.5, 0], index=index)
378 # print('>>>2\n', obj2)
379 # print('>>>3\n', obj2.index is index)
380 # print("\n判断列和索引是否存在")
381 # pop = {'Nevada': {20001: 2.4, 2002: 2.9},
382 # 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
383 # frame3 = DataFrame(pop)
384 # print('>>>4\n', 'Ohio' in frame3.columns)
385 # print('>>>5\n', '2003' in frame3.index)
386 # except Exception:
387 # print("出问题！！！")
388
389 # try:
390 # # print("\n 重新指定索引及顺序")
391 # # obj = Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
392 # # print('>>>1\n', obj)
393 # # obj2 = obj.reindex(['a', 'b', 'd', 'c', 'e'])
394 # # print('>>>2.0\n', obj2)
395 # # print('>>>2.1\n', obj.reindex(['a', 'b', 'd', 'c', 'e'], fill_value=0)) # 指定不存在元素的默认值
396 # # print("\n重新指定索引并指定填元素充方法")
397 # obj3 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
398 # print('>>>3\n', obj3)
399 # print('>>>4\n', obj3.reindex(range(6), method='ffill'))
400 # print("\n 对DataFrame重新指定索引")
401 # frame = DataFrame(np.arange(9).reshape(3, 3),
402 # index=['a', 'c', 'd'],
403 # columns=['Ohio', 'Texas', 'California'])
404 # print('>>>5\n', frame)
405 # frame2 = frame.reindex(['a', 'b', 'c', 'd'])
406 # print('>>>6\n', frame2)
407 # print("\n 重新指定column")
408 # states = ['Texas', 'Utah', 'California']
409 # print('>>>7\n', frame.reindex(columns=states))
410 # print("\n 对DataFrame重新指定索引并指定填元素充方法")
411 # print(frame.reindex(index=['a', 'b', 'c', 'd'],method='ffill')) #,columns=states
412 # # print('>>>8\n', frame.ix[ 'a', 'b', 'd', 'c'])#, states
413 # print('>>>9\n', )
414 # except Exception:
415 # print("出问题！！！")
416
417 # try:
418 # print("\n Series根据索引删除元素")
419 # obj = Series(np.arange(8.),index=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
420 # new_obj = obj.drop('c')
421 # print('>>>1\n', new_obj)
422 # print('>>>2\n', obj.drop(['d', 'c']))
423 # print("\n DataFrame删除元素可指定索引或列")
424 # data = DataFrame(np.arange(16).reshape((4, 4)),
425 # index=['Ohio', 'Colorado', 'Utah', 'New York'],
426 # columns=['one', 'two', 'three', 'four'])
427 # print('>>>3\n', data.drop(['Colorado', 'Ohio']))
428 # print('>>>4\n', data)
429 # print('>>>5\n', data.drop('two', axis=1))
430 # print('>>>6\n', data)
431 # print('>>>7\n', data.drop(['two', 'four'], axis=1))
432 # print('>>>8\n', data)
433 # print('>>>9\n', )
434 # except Exception:
435 # print("出问题！！！")
436
437 # try:
438 # # print("\n Series的索引，默认数字索引可以工作")
439 # obj = Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
440 # # print(obj)
441 # # print('>>>1\n', obj['b'])
442 # # print('>>>2\n', obj[3])
443 # # print('>>>3\n', obj[[1, 3]])
444 # # print('>>>4\n', obj[obj < 2])
445 # # print("\n Series的数组切片")
446 # # print('>>>5\n', obj['b':'c']) # 闭区间
447 # # obj['b':'c'] = 5
448 # # print('>>>6\n', obj)
449 # # print("\n DataFrame的索引")
450 # data = DataFrame(np.arange(16).reshape((4, 4)),
451 # index=['Ohio', 'Colorado', 'Utah', 'New York'],
452 # columns=['one', 'two', 'three', 'four'])
453 # print('>>>7\n', data) # 打印列
454 # print('>>>8\n', data['two'])
455 # print('>>>9\n', data[['three', 'one']])
456 # print('>>>10\n',data[:2])
457 # print('>>>11\n',data.loc['Colorado', ['two', 'three']]) # 指定索引和列
458 # print('>>>12\n', data.loc[['Colorado', 'Utah'], ['two', 'three']]) #
459 # print('>>>13\n', data.iloc[2]) # 打印第2行（从0开始）
460 # print('>>>14\n', data.loc[:'Utah', 'two']) # 从开始到Utah，第2列
461 # print("\n 根据条件选择")
462 # print('>>>15\n', data[data.three > 5])
463 # print('>>>16\n', data < 5) # 打印True或者False
464 # data[data < 5] = 0
465 # print('>>>17\n', data)
466 # except Exception:
467 # print("出问题！！！")
468
469 # try:
470 # # print("\n 加法")
471 # s1 = Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])
472 # s2 = Series([-2.1, 3.6, -1.5, 4, 3.1], index=['a', 'c', 'e', 'f', 'g'])
473 # print('>>>1\n', s1)
474 # print('>>>2\n', s2)
475 # print('>>>3\n', s1 + s2)
476 # print("\n DataFrame加法，索引和列都必须匹配")
477 # df1 = DataFrame(np.arange(9.).reshape((3, 3)),
478 # columns=list('bcd'),
479 # index=['Ohio', 'Texas', 'Colorado'])
480 # df2 = DataFrame(np.arange(12).reshape((4, 3)),
481 # columns=list('bde'),
482 # index=['Utah', 'Ohio', 'Texas', 'Oregon'])
483 # print('>>>4\n', df1)
484 # print('>>>5\n', df2)
485 # print('>>>6\n', df1 + df2)
486 # print("\n 数据填充")
487 # df1 = DataFrame(np.arange(12.).reshape((3, 4)), columns=list('abcd'))
488 # df2 = DataFrame(np.arange(20.).reshape((4, 5)), columns=list('abcde'))
489 # print('>>>7\n', df1)
490 # print('>>>8\n', df2)
491 # print('>>>9\n', df1.add(df2, fill_value=0))
492 # print('>>>10\n',df1.reindex(columns=df2.columns, fill_value=0))
493 # print("\n DataFrame与Series之间的操作")
494 # arr = np.arange(12.).reshape((3, 4))
495 # print('>>>11\n', arr)
496 # print('>>>12\n', arr[0])
497 # print('>>>13\n', arr - arr[0])
498 # frame = DataFrame(np.arange(12).reshape((4, 3)),
499 # columns=list('bde'),
500 # index=['Utah', 'Ohio', 'Texas', 'Oregon'])
501 # series = frame.iloc[0]
502 # print('>>>14\n', frame)
503 # print('>>>15\n', series)
504 # print('>>>16\n', frame - series)
505 # series2 = Series(range(3), index=list('bef'))
506 # print('>>>17\n', frame + series2)
507 # series3 = frame['d']
508 # print('>>>19\n', frame.sub(series3, axis=0))
509 # except Exception:
510 # print("出问题！！！")
511
512 # try:
513 # print("\n 函数")
514 # frame = DataFrame(np.random.randn(4, 3),
515 # columns=list('bde'),
516 # index=['Utah', 'Ohio', 'Texas', 'Oregon'])
517 # print('>>>1\n', frame)
518 # print('>>>2\n', np.abs(frame))
519 # print("\n lambda以及应用")
520 # f = lambda x: x.max() - x.min()
521 # print('>>>3\n', frame.apply(f))
522 # print('>>>4\n', frame.apply(f, axis=1))
523 # def f(x):
524 # return Series([x.min(), x.max()], index=['min', 'max'])
525 # print('>>>5\n', frame.apply(f))
526 # print("\n applymap和map")
527 # _format = lambda x: '%.2f' % x
528 # print('>>>6\n', frame.applymap(_format))
529 # print('>>>7\n', frame['e'].map(_format))
530 # except Exception:
531 # print("出问题！！！")
532
533 # try:
534 # print("\n 根据索引排序，对于DataFrame可以指定轴")
535 # obj = Series(range(4), index=['d', 'a', 'b', 'c'])
536 # print(obj)
537 # print('>>>1\n', obj.sort_index())
538 # frame = DataFrame(np.arange(8).reshape((2, 4)),
539 # index=['three', 'one'],
540 # columns=list('dabc'))
541 # print(frame)
542 # print('>>>2\n', frame.sort_index())
543 # print('>>>3\n', frame.sort_index(axis=1))
544 # print('>>>4\n', frame.sort_index(axis=1, ascending=False)) # 降序
545 # print("\n根据值排序")
546 # obj2 = Series([4, 7, -3, 2])
547 # print(obj2)
548 # print('>>>5\n', obj2.sort_values()) # order已淘汰
549 # print("\n DataFrame指定列排序")
550 # frame2 = DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
551 # print('>>>6\n', frame2)
552 # print('>>>7\n', frame2.sort_values(by='b'))
553 # print('>>>8\n', frame2.sort_values(by=['a', 'b']))
554 # print("\n rank，求排名的平均位置(从1开始)")
555 # obj3 = Series([7, -5, 7, 4, 2, 0, 4]) #对应排名：-5(1), 0(2), 2(3), 4(4), 4(5), 7(6), 7(7)
556 # print(obj3)
557 # print('>>>9\n', obj3.rank())
558 # print('>>>10\n', obj3.rank(method='first')) # 去第一次出现，不求平均值。
559 # print('>>>11\n', obj3.rank(ascending=False, method='max')) # 逆序，并取最大值。所以-5的rank是7.
560 # frame4 = DataFrame({'b': [4.3, 7, -3, 2],
561 # 'a': [0, 1, 0, 1],
562 # 'c': [-2, 5, 8, -2.5]})
563 # print('>>>12\n', frame4)
564 # print('>>>13\n', frame4.rank(axis=1))
565
566 # except Exception:
567 # print("出问题！！！")
568
569 # try:
570 # print("\n 重复的索引")
571 # obj = Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
572 # print(obj)
573 # print('>>>1\n', obj.index.is_unique) # 判断是非有重复索引
574 # df = DataFrame(np.random.randn(4, 3), index=['a', 'a', 'b', 'b'])
575 # print('>>>3\n', df)
576 # # print('>>>4\n', df.loc['b'].loc[0])
577 # # print('>>>5\n', df.loc['b'].loc[1])
578 # except Exception:
579 # print("出问题！！！")
580
581 # try:
582 # print("\n 求和")
583 # df = DataFrame([[1.4, np.nan], [7.1, -4.5], [np.nan, np.nan], [0.75, -1.3]],
584 # index=['a', 'b', 'c', 'd'],
585 # columns=['one', 'two'])
586 # print('>>>1\n', df)
587 # print('>>>2\n', df.sum()) # 按列求和
588 # print('>>>3\n', df.sum(axis=1)) # 按行求和
589 # print("\n 平均数")
590 # print('>>>4\n', df.mean(axis=1, skipna=False))
591 # print('>>>5\n', df.mean(axis=1))
592 # print("\n 其它")
593 # print('>>>6\n', df.idxmax())
594 # print('>>>7\n', df.cumsum())
595 # print('>>>8\n', df.describe())
596 # obj = Series(['a', 'a', 'b', 'c'] * 4)
597 # print('>>>9\n', obj.describe())
598 # except Exception:
599 # print("出问题！！！")
600
601 # try:
602 # # 此部分有问题
603 # print("\n 相关性与协方差")
604 # all_data = {}
605 # for ticker in ['AAPL', 'IBM', 'MSFT', 'GOOG']:
606 # all_data[ticker] = web.get_data_yahoo(ticker, '4/1/2016', '7/15/2015')
607 # price = DataFrame({tic: data['Adj Close'] for tic, data in all_data.iteritems()})
608 # volume = DataFrame({tic: data['Volume'] for tic, data in all_data.iteritems()})
609 # returns = price.pct_change()
610 # print('>>>1\n', returns.tail())
611 # print('>>>2\n', returns.MSFT.corr(returns.IBM))
612 # print('>>>3\n', returns.corr()) # 相关性，自己和自己的相关性总是1
613 # print('>>>4\n', returns.cov()) # 协方差
614 # print('>>>5\n', returns.corrwith(returns.IBM))
615 # print('>>>6\n', returns.corrwith(returns.volume))
616 # except Exception:
617 # print("出问题！！！")
618
619 # try:
620 # print("\n 去重")
621 # obj = Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
622 # print(obj)
623 # print('>>>1\n', obj.unique())
624 # print('>>>2\n', obj.value_counts())
625 # print("\n 判断元素存在")
626 # mask = obj.isin(['b', 'c'])
627 # print('>>>3\n', mask)
628 # print('>>>4\n', obj[mask] ) # 只打印元素b和c
629 # data = DataFrame({'Qu1': [1, 3, 4, 3, 4],
630 # 'Qu2': [2, 3, 1, 2, 3],
631 # 'Qu3': [1, 5, 2, 4, 4]})
632 # print('>>>5\n', data)
633 # print('>>>6\n', data.apply(pd.value_counts).fillna(0))
634 # print('>>>7\n', data.apply(pd.value_counts, axis=1).fillna(0))
635 #
636 # except Exception:
637 # print("出问题！！！")
638
639 # try:
640 # print("\n 作为null处理的值")
641 # string_data = Series(['aardvark', 'artichoke', np.nan, 'avocado'])
642 # print('>>>1\n', string_data)
643 # print('>>>2\n', string_data.isnull())
644 # string_data[0] = None
645 # print('>>>3\n', string_data.isnull())
646 # except Exception:
647 # print("出问题！！！")
648
649 # try:
650 # print("\n 丢弃NA")
651 # data = Series([1, NA, 3.5, NA, 7])
652 # print('>>>1\n', data.dropna())
653 # print('>>>2\n', data[data.notnull()])
654 # print("\n DataFrame对丢弃NA的处理")
655 # data = DataFrame([[1., 6.5, 3.], [1., NA, NA],
656 # [NA, NA, NA], [NA, 6.5, 3.]])
657 # print(data)
658 # print('>>>3\n', data.dropna() ) # 默认只要某行有NA就全部删除
659 # print('>>>4\n', data.dropna(how='all')) # 全部为NA才删除
660 # data[4] = NA # 新增一列
661 # print(data)
662 # print('>>>5\n', data.dropna(axis=1, how='all'))
663 # data = DataFrame(np.random.randn(7, 3))
664 # data.loc[:4, 1] = NA
665 # data.loc[:2, 2] = NA
666 # print('>>>6\n', data)
667 # print('>>>7\n', data.dropna(thresh=2)) # 每行至少要有2个非NA元素
668 # except Exception:
669 # print("出问题！！！")
670
671 # try:
672 # print("\n 填充0")
673 # df = DataFrame(np.random.randn(7, 3))
674 # print('>>>1.0\n', df)
675 # df.loc[:4, 1] = NA
676 # df.loc[:2, 2] = NA
677 # print('>>>1.1\n', df.fillna(0))
678 # print('>>>2\n', df.fillna(2, inplace=True))
679 # print('>>>3\n', df)
680 # print("\n 不同行列填充不同的值")
681 # print('>>>4\n', df.fillna({1: 4, 3: -1})) # 第3列不存在
682 # print("\n 不同的填充方式")
683 # df = DataFrame(np.random.randn(6, 3))
684 # df.loc[:4, 1] = NA
685 # df.loc[:2, 2] = NA
686 # print('>>>5\n', df)
687 # print('>>>6\n', df.fillna(method='ffill'))
688 # print('>>>7\n', df.fillna(method='ffill', limit=2))
689 # print("\n 用统计数据填充")
690 # data = Series([1., NA, 3.5, NA, 7])
691 # print('>>>8\n', data)
692 # except Exception:
693 # print("出问题！！！")
694
695 # try:
696 # print("\n Series的层次索引")
697 # data = Series(np.random.randn(10),
698 # index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'],
699 # [1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])
700 # print('>>>1\n', data)
701 # print('>>>2\n', data.index)
702 # print('>>>3\n', data.b)
703 # print('>>>4\n', data['b':'c'])
704 # print('>>>5\n', data[:4])
705 # print('>>>6\n', data.unstack())
706 # print('>>>7\n', data.unstack().stack())
707 # print("\n DataFrame的层次索引")
708 # frame = DataFrame(np.arange(12).reshape((4, 3)),
709 # index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
710 # columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']])
711 # print('>>>8\n', frame)
712 # frame.index.names = ['key1', 'key2']
713 # frame.columns.names = ['state', 'color']
714 # print('>>>9\n', frame)
715 # print('>>>10\n', frame.loc['a', 1])
716 # print('>>>11\n', frame.loc['a', 2]['Colorado'])
717 # print('>>>12\n', frame.loc['a', 2]['Ohio']['Red'])
718 # print("\n 直接用MultiIndex创建层次索引结构")
719 # asd = MultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Gree', 'Red', 'Green']],
720 # names=['state', 'color'])
721 # print('>>>13\n', asd)
722 # except Exception:
723 # print("出问题！！！")
724
725 # try:
726 # print("\n 索引层级交换")
727 # frame = DataFrame(np.arange(12).reshape((4, 3)),
728 # index=[['a', 'a', 'b', 'b'], [1, 2, 5, 4]],
729 # columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']])
730 # frame.index.names = ['key1', 'key2']
731 # print(frame)
732 # frame_swapped = frame.swaplevel('key1', 'key2') # 交换
733 # print('>>>1\n', frame_swapped)
734 # print('>>>2\n', frame_swapped.swaplevel(0, 1))
735 # print("\n 根据索引排序")
736 # print('>>>3\n', frame.sort_index(level='key1'))
737 # print('>>>4\n', frame.sort_index(0, 1).sort_index(0))
738 # except Exception:
739 # print("出问题！！！")
740
741 # try:
742 # print("\n 根据指定的key计算统计信息")
743 # frame = DataFrame(np.arange(12).reshape((4, 3)),
744 # index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
745 # columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']])
746 # frame.index.names = ['key1', 'key2']
747 # print('>>>1\n', frame)
748 # print('>>>2\n', frame.sum(level='key2'))
749 # except Exception:
750 # print("出问题！！！")
751
752 # try:
753 # print("\n 使用列生成层次索引")
754 # frame = DataFrame({'a': range(7),
755 # 'b': range(7, 0, -1),
756 # 'c': ['one', 'one', 'one', 'two', 'two', 'two', 'two'],
757 # 'd': [0, 1, 2, 0, 1, 2, 3]})
758 # print('>>>1\n', frame)
759 # print('>>>2\n', frame.set_index(['c', 'd'])) # 把c/d列变成索引
760 # print('>>>3\n', frame.set_index(['c', 'd'], drop=False)) # 列依然保留
761 # frame2 = frame.set_index(['c', 'd'])
762 # print('>>>4\n', frame2.reset_index())
763 # except Exception:
764 # print("出问题！！！")
765
766 # try:
767 # print("\n 整数索引")
768 # ser = Series(np.arange(9))
769 # print('>>>1\n', ser)
770 # try:
771 # print(ser[-1]) # 这里会有歧义
772 # except:
773 # print(sys.exc_info()[0])
774 # ser2 = Series(np.arange(5.), index=['a', 'b', 'c', 'e', 'f'])
775 # print('>>>2.0\n', ser2)
776 # print('>>>2.1\n', ser2[-2])
777 # ser3 = Series(range(3), index=[-5, 1, 3])
778 # print('>>>3.0\n', ser3)
779 # print('>>>3.1\n', ser3.iloc[2]) # 避免直接用[2]产生的歧义
780 # print("\n对DataFrame使用整数索引 ")
781 # frame = DataFrame(np.arange(6).reshape((3, 2)), index=[2, 0, 1])
782 # print('>>>4\n', frame)
783 # print('>>>5\n', frame.iloc[0])
784 # print('>>>6\n', frame.iloc[:, 1])
785 # print('>>>7\n', )
786 # except Exception:
787 # print("出问题！！！")
788
789 # try:
790 # print("此部分有问题")
791 # print('>>>1\n', )
792 # print('>>>2\n', )
793 # print('>>>3\n', )
794 # print('>>>4\n', )
795 # print('>>>5\n', )
796 # print('>>>6\n', )
797 # print('>>>7\n', )
798 # print('>>>8\n', )
799 # print('>>>9\n', )
800 # print('>>>10\n', )
801 # print('>>>11\n', )
802 # print('>>>12\n', )
803 # print('>>>13\n', )
804 # print('>>>14\n', )
805 # print('>>>15\n', )
806 # print('>>>16\n', )
807 # print('>>>17\n', )
808 # except Exception:
809 # print("出问题！！！")
810
811 # try:
812 # print("\n stock")
813 # names = ['date',
814 # 'time',
815 # 'opening_price',
816 # 'ceiling_price',
817 # 'floor_price',
818 # 'closing_price',
819 # 'volume',
820 # 'amount']
821 # raw = pd.read_csv('use_to_A_V03_Pandas.csv', names=names, header=None, index_col='date', parse_dates=True)
822 #
823 # # print('>>>1\n', raw)
824 # # print('>>>2\n', raw.head())
825 #
826 # '''
827 # # 根据涨跌幅判断数据是否有效
828 # def _valid_price(prices):
829 # return (((prices.max() - prices.min()) / prices.min()) < 0.223).all()
830 #
831 # # 按日期分组
832 # days = raw.groupby(level = 0).agg(
833 # {'opening_price':lambda prices: _valid_price(prices) and prices[0] or 0,
834 # 'ceiling_price':lambda prices: _valid_price(prices) and np.max(prices) or 0,
835 # 'floor_price':lambda prices: _valid_price(prices) and np.min(prices) or 0,
836 # 'closing_price':lambda prices: _valid_price(prices) and prices[-1] or 0,
837 # 'volume':'sum',
838 # 'amount':'sum'})
839 # print days.head()
840 # print
841 #
842 # # 缺少数据处理，因为周末没有交易。
843 # start = days.iloc[0:1].index.tolist()[0]
844 # end = days.iloc[-2:-1].index.tolist()[0]
845 # new_idx = pd.date_range(start = start, end = end)
846 # print new_idx
847 # data = days.reindex(new_idx) # 重新索引
848 # zero_values = data.loc[~(data.volume > 0)].loc[:, ['volume', 'amount']]
849 # data.update(zero_values.fillna(0)) # 交易量和金额填0
850 # data.fillna(method = 'ffill', inplace = True) # 价格用前一天的填充
851 # print data.head()
852 # print
853 #
854 # # 计算30各自然日里的股票平均波动周率
855 # def gen_item_group_index(total, group_len):
856 # group_count = total / group_len
857 # group_index = np.arange(total)
858 # for i in xrange(group_count):
859 # group_index[i * group_len: (i+ 1) * group_len] = i
860 # group_index[(i + 1) * group_len:] = i +1
861 # return group_index.tolist()
862 #
863 # period = 30
864 # group_index = gen_item_group_index(len(data), period)
865 # data['group_index'] = group_index
866 # print data.head().append(data.tail())
867 #
868 # # 为负表示先出现最高价再出现最低价，即下跌波动。
869 # def _ceiling_price(prices):
870 # return prices.idxmin() < prices.idxmax() and np.max(prices) or (-np.max(prices))
871 #
872 # group = data.groupby('group_index').agg(
873 # {'volume': 'sum',
874 # 'floor_price': 'min',
875 # 'ceiling_price': _ceiling_price})
876 # print group.head()
877 # date_col = pd.DataFrame({'group_index': group_index, 'date': new_idx})
878 # print date_col
879 # group['date'] = date_col.groupby('group_index').agg('first') # 为每个索引添加开始日期
880 # print group.head()
881 # group['ripples_ratio'] = group.ceiling_price / group.floor_price # 计算并添加波动率
882 # print group.head()
883 # print
884 #
885 # # 波动率排序
886 # ripples = group.sort_values('ripples_ratio', ascending = False)
887 # print ripples
888 # print ripples.head(10).ripples_ratio.mean()
889 # print ripples.tail(10).ripples_ratio.mean()
890 # print
891
892 # # 计算涨跌幅
893 # rise = data.closing_price.diff()
894 # data['rise'] = rise
895 # print data.head()
896 # '''
897 # except Exception:
898 # print("出问题！！！")
899
900 # try:
901 # print('>>>1\n', )
902 # except Exception:
903 # print("出问题！！！")
--------
---------------------------------------------------------------------------