Data Algorithm learn of Numpy

 Author: 楚格

2018-11-28   19:11:09

IDE: Pycharm2018.03   Anaconda 3.5.1 Python 3.7   

KeyWord :  NumPy 

Explain:   更新

---------------------------------------------------------------------------

--------

 

  1 # -*- coding: utf-8 -*-
  2 # ---------------------------------
  3 
  4 """
  5 # Author  : chu ge
  6 # Function: Numpy
  7 #
  8 """
  9 
 10 # ---------------------------------
 11 '''
 12 # --------------------------------
 13 # 导入模块 
 14 # 1.系统库
 15 # 2.第三方库
 16 # 3.相关定义库
 17 # --------------------------------
 18 '''
 19 # 1.系统库、
 20 import sys
 21 import os
 22 
 23 # 2.第三方库
 24 import numpy as np
 25 from scipy import linalg
 26 import pandas as pd
 27 import matplotlib.pyplot as plt
 28 import seaborn as sns
 29 
 30 import timeit
 31 import numpy.random as np_random
 32 from numpy.linalg import inv, qr
 33 from random import normalvariate
 34 
 35 import pylab
 36 #
 37 '''
 38 ============================================================================
 39 #》》》》》》》》》》》》》》》》》》》》》》》》
 40 
 41 ----------------------------------------------
 42 Numpy
 43     提供常用的数值数组、矩阵等函数,是基于向量化的运算,进行数值运算时Numpy数组比list效率高
 44     NumPy是Python语言的一个扩充程序库。支持高级大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。
 45     
 46     快速高效的多维数组对象ndarray
 47         • 用于对数组执行元素级计算以及直接对数组执行数学运算的函数
 48         • 用于读写硬盘上基于数组的数据集的工具
 49         • 线性代数运算、傅里叶变换,以及随机数生成
 50         • 用于将C、C++、Fortran代码集成到Python的工具
 51         • 除了为Python提供快速的数组处理能力,NumPy在数据分析方面还有另外一
 52         个主要作用,即作为在算法之间传递数据的容器。
 53 
 54 Scipy
 55     是一种使用NumPy来做高等数学、信号处理、优化、统计的扩展包
 56     
 57 Pandas
 58     是一种构建于Numpy的高级数据结构和精巧工具,快速简单的处理数据。
 59     n 支持自动或明确的数据对齐的带有标签轴的数据结构。
 60     n 整合的时间序列功能。
 61     n 以相同的数据结构来处理时间序列和非时间序列。
 62     n 支持传递元数据(坐标轴标签)的算术运算和缩减。
 63     n 灵活处理丢失数据。
 64     n 在常用的基于数据的数据库(例如基于SQL)中的合并和其它关系操作。
 65     o 数据结构:Series和DataFrame
 66     
 67 matplotlib
 68     Python绘图库
 69     
 70 nltk
 71     自然语言处理工具包(Natural Language Toolkit)
 72     n 安装:pip install -U nltk
 73     n 引入:import nltk
 74     n 下载预料库:nltk.download()
 75     n 文本提取
 76     n 词汇切分
 77     n 词频分析
 78     n 词袋模型
 79     n 情感分析
 80 
 81 igraph
 82     图计算和社交网络分析
 83     o 安装:
 84         n pip install -U python-igraph
 85         n conda install -c marufr python-igraph=0.7.1.post6
 86 Scikit-learn
 87     o Scikit-learn是建立在Scipy之上的一个用于机器学习的Python模块。
 88         n 安装:pip install -U scikit-learn / conda install scikit-learn
 89 ----------------------------------------------
 90 
 91 Numpy
 92 ----------------------------------------------
 93 数组 创建 函数
 94 array               将输入数据(列表、元组、数组或其它序列类型)转换为ndarray。
 95                     要么推断出dtype,要么显示指定dtype。默认直接复制输入数据。
 96 asarray             将输入转换为darray,如果输入本身就是一个ndarray就不进行复制。
 97 arange              类似于内置的range,但返回一个ndarray而不是列表。
 98 ones,ones_like      根据指定形状和dtype创建一个全1数组。ones_like以另一个数组为参数,
 99                     并根据其形状和dtype创建一个全1数组。
100 zeros,zeros_like    类似于ones和ones_like,只不过产生的是全0数组而已。
101 empty, empty_like   创建数组,只分配内存空间但不填充任何值。
102 eye,identity        创建一个正方的N * N单位矩阵
103 
104 
105 数据 类型 说明
106 int8,  uint8 - i1, u1                有/无符号的8位整型
107 int16, uint16 - i2, u2              有/无符号的16位整型
108 int32, uint32 - i4, u4              有/无符号的32位整型
109 int64, uint64 - i8, u8              有/无符号的64位整型
110 float16 - f2                        半精度浮点数
111 float32 - f4 or f                   标准的单精度浮点数,与C的float兼容。
112 float64 - f8 or d                   标准的双精度浮点数。与C的double和Python的float兼容。
113 float128 - f16 or g                 扩展精度浮点数
114 complex64/128/256 -c8/16/32         分别用两个32位,64位或128位浮点数表示的复数。
115 bool - ?                            存储True和False值的布尔类型
116 object - O                          Python对象类型
117 string_ - S                         固定长度的字符串类型。S10代表长度为10的字符串。
118 unicode_ - U                        固定长度的unicode类型
119 
120 
121 NumPy的ndarray 数组和标量之间的运算
122     • 不用编写循环即可对数据执行批量运算
123     • 大小相等的数组之间的任何算术运算都会将运算应用到元素级
124     • 数组与标量的算术运算也会将那个标量值传播到各个元素
125 
126 NumPy的ndarray 基本的索引和切片
127     • 索引原理
128     • 切片原理
129     
130 NumPy的ndarray 布尔型索引
131     • 布尔型数组的长度必须跟被索引的轴长度一致。
132     • 可以将布尔型数组跟切片、整数(或整数序列)混合使用
133     
134 NumPy的ndarray 数组转置和轴对换
135     • 一维/二维数组转置
136     • 高维数组轴对换 
137     
138 NumPy的ndarray 快速的元素级数组函数
139     • 一元函数 I
140     abs, fabs       计算整数、浮点数或复数的绝对值。对于非复数值,可以使用更快的fabs。
141     sqrt            计算各元素的平方根。相当于arr ** 0.5
142     sqare           计算各元素的平方。相当于arr ** 2
143     exp             计算各元素的e^x
144     log,log10,      分别为自然对数、底数为10的log、底数为2的log和log(1 + x)。
145     log2,log1p 
146     sign            计算各元素的正负号:1(正数)、0(零)、-1(负数)。
147     ceil            计算各元素的ceiling值,即大于等于该值的最小整数。
148     floor           计算各元素的floor值,即小于等于该值的最小整数。
149     
150     一元函数 II
151     rint            将各元素值四舍五入到最接近的整数,保留dtype。
152     modf            将数组的小数部分与整数部分以两个独立数组的形式返还。
153     isnan           返回一个表示“哪些值是NaN(这不是一个数字)”的布尔型数组
154     isfinite,       分别返回一个表示“哪些元素是有限的(非inf,非NaN)”或“哪些元素是无穷的”的布尔型数组
155     isinf 
156     cos,            普通型或双曲型三角函数
157     cosh, 
158     sin, 
159     sinh, 
160     tan, 
161     tanh            反三角函数
162     arccos, 
163     arccosh, 
164     arcsin, 
165     arcsinh,
166     arctan, 
167     arctanh
168     logical_not     计算各元素not x的真值。相当于-arr。
169     
170     • 二元函数 I
171     add             将数组中对应的元素相加
172     subtract        从第一个数组中减去第二个数组中的元素
173     multiply        数组元素相乘
174     divide,         除法或向下取整除法
175     floor_divide 
176     power           对第一个数组中的元素A和第二个数组中对应位置的元素B,计算A^B。
177     maximum, fmax   元素级的最大值计算。fmax将忽略NaN。
178     minimum, fmin   元素级的最小值计算。fmin将忽略NaN。
179     mod             元素级的求模计算
180     
181     二元函数 II
182     copysign        将第二个数组中的符号复制给第一个数组中的值
183     greater,        执行元素级的比较,最终产生布尔型数组。
184     greater_equal, 
185     less,
186     less_equal,
187     equal, 
188     not_equal
189     logical_and,    执行元素级的真值逻辑运算,最终产生布尔型数组。
190     logical_or,
191     logical_xor
192     
193     
194 利用数组进行数据处理 
195     • NumPy数组使你可以将许多种数据处理任务表述为简洁的数组表达式(否则需
196     要编写循环)。用数组表达式代替循环的做法,通常被称为矢量化。
197     • 矢量化数组运算要比等价的纯Python方式快上一两个数量级
198     
199 利用数组进行数据处理 将条件逻辑表述为数组运算
200     • 列表推导的局限性
201     • 纯Python代码,速度不够快。
202     • 无法应用于高维数组
203     • where和where的嵌套
204     
205 利用数组进行数据处理 数学和统计方法
206     • 数学和统计方法
207     sum         对数组中全部或某轴向的元素求和。零长度的数组的sum为0。
208     mean        算术平均数。零长度的数组的mean为NaN。
209     std, var    分别为标准差和方差,自由度可调(默认为n)。
210     min, max    最大值和最小值
211     argmin      分别为最大值和最小值的索引
212     cumsum      所有元素的累计和
213     cumprod     所有元素的累计积
214 
215     • 标准差和方差的解释
216     • cumsum和cumprod的解释
217     • 带axis参数的统计函数
218     
219     
220 利用数组进行数据处理 用于布尔型数组的方法
221     • sum对True值计数
222     • any和all测试布尔型数组,对于非布尔型数组,所有非0元素将会被当做True
223     
224 利用数组进行数据处理 排序
225     • 直接排序
226     • 指定轴排序
227     ---- Error
228     
229 利用数组进行数据处理 去重以及其它集合运算
230     • 去重以及其它集合运算
231     unique(x)           计算x中的唯一元素,并返回有序结果。
232     intersect1d(x, y)   计算x和y中的公共元素,并返回有序结果。
233     union1d(x, y)       计算x和y的并集,并返回有序结果。
234     in1d(x, y)          得到一个表述"x的元素是否包含于y"的布尔型数组
235     setdiff1d(x, y)     集合的差,即元素在x中且不在y中
236     setxor1d(x, y)      集合的异或,即存在于一个数组中但不同时存在于两个数组中的元素。
237     
238 数组文件的输入输出
239     • 将数组以二进制格式保存到磁盘
240     • 存取文本文件
241     
242 线性代数
243 • 常用的numpy.linalg函数 I
244     diag                以一维数组的形式返回方阵的对角线(或非对角线元素),获将一维数组转换为方阵(非对角线元素为0)。
245     dot                 矩阵乘法
246     trace               计算对角线元素的和
247     det                 计算矩阵行列式
248     eig                 计算方阵的特征值和特征向量
249     inv                 计算方阵的逆 
250 •常用的numpy.linalg函数 II
251     pinv                计算矩阵的Moore-Penrose伪逆
252     qr                  计算QR分解
253     svd                 计算奇异值分解
254     solve               解线性方程Ax = b,其中A为
255     
256     
257 随机数生成
258     seed                确定随机数生成器的种子
259     permutation         返回一个序列的随机排列或返回一个随机排列的返回
260     shuffle             对一个序列就地随机乱序
261     rand                产生均匀分布的样本值
262     randint             从给定的上下限范围内随机选取整数
263     randn               产生正态分布(平均值为0,标准差为1)
264     binomial            产生二项分布的样本值
265     normal              产生正态(高斯)分布的样本值
266     beta                产生Beta分布的样本值
267     chisquare           产生卡方分布的样本值
268     gamma               产Gamma分布的样本值
269     uniform             产生在[0, 1]中均匀分布的样本值
270     
271    
272 高级应用 数组重塑
273     • reshape重塑数组
274     • -1自动推导维度大小 
275     
276     
277     
278 高级应用 数组的合并和拆分
279 • 数组连接函数
280     concatenate         最一般化的连接,沿一条轴连接一组数组
281     vstack, row_stack   以面向行的方式对数组进行堆叠(沿轴0)
282     hstack,             以面向行的方式对数组进行堆叠(沿轴1)
283     column_stack        类似于hstack,但是会先将一维数组转换为二维列向量。
284     dstack              以面向“深度”的方式对数组进行堆叠(沿轴2)
285     split               沿指定轴在指定的位置拆分数组
286     hsplit,             split的便捷化函数,分别沿着轴0、轴1和轴2进行拆分。
287     vsplit,     
288     dsplit 
289     
290     
291     
292 高级应用 数组的合并和拆分
293     • _r对象
294     • _c对象
295 
296 高级应用 元素的重复操作
297     • _tile
298     • _repeat
299 
300 高级应用 花式索引的等价函数
301     • take
302     • put
303     
304     
305 例题分析 距离矩阵计算
306     给定m × n阶矩阵X,满足X = [x1, x2, ... xn],这里第i列向量是m维向量。
307     求n × n矩阵,使得Dij = ||xi - xj||2
308 ----------------------------------------------
309 
310 
311 
312 ============================================================================
313 '''
314 #
315 
316 #
317 '''
318 # ============================================================================
319 # Function:  
320 # Explain :  输入参数   
321 #         :  输出参数  
322 # ============================================================================
323 '''
324 
325 
326 # ============================================================================
327 '''
328 # ============================================================================
329 #   测试专用
330 # ============================================================================
331 '''
332 if __name__ == "__main__":
333     print("123")
334     # # numpy
335     # print(np.arange(10)**2)
336     # # scipy
337     # var_A = np.array([[1,2],[3,4]])
338     # print(linalg.det(var_A))
339     # # pandas
340     # print(pd.Series([1,3,5,np.nan,6,8]))
341     # print(pd.date_range('20130101',periods=3))
342     # dates = pd.date_range('20130101', periods=6)
343     # df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
344     # print(df)
345     # df1 = df.sort_values(by='B')
346     # print(df1)
347     #
348     # # # mat plot lib
349     # plt.plot([1, 2, 3])
350     # plt.ylabel('some numbers')
351     # plt.show()
352     # # sea born
353     # sns.set(color_codes=True)
354     #
355     # # x = np.random.normal(loc=0.0, scale=1.0,size=100)
356     # # sns.distplot(x)
357 
358 
359     # numpy
360         #
361     # print('使用普通一维数组生成NumPy一维数组')
362     # data = [6, 7.5, 8, 0, 1]
363     # arr  = np.array(data)
364     # print( arr, arr.dtype )
365     # print( '使用普通二维数组生成NumPy二维数组')
366     # data = [[1, 2, 3, 4], [5, 6, 7, 8]]
367     # arr = np.array(data)
368     # print( arr, '\n 打印数组维度: ',arr.shape)                   # 打印数组维度
369     # print('使用zeros/empty')
370     # print('\n生成10个0的一维数组: \n ',np.zeros(10))              # 生成包含10个0的一维数组
371     # print('\n生成3*6的二维数组: \n ', np.zeros((3, 6)))           # 生成3*6的二维数组
372     # print('\n生成2*3*2的三维数组,元素未初始化: \n',np.empty((2, 3, 2)))   # 生成2*3*2的三维数组,所有元素未初始化
373     # print('\n生成连续元素: \n', np.arange(15))
374         #
375 
376 
377     # print('\n生成数组时指定数据类型:',)
378     # arr = np.array([1, 2, 3], dtype=np.float64)
379     # arr1 = np.array([1, 2, 3], dtype=np.int32)
380     # print( arr.dtype, arr1.dtype )
381     # print('\n astype复制数组并转换数据类型:', )
382     # int_arr = np.array([1, 2, 3, 4, 5])
383     # float_arr = int_arr.astype(np.float)
384     # print(int_arr.dtype, float_arr.dtype )
385     # print('\n 使用astype将float转换为int时小数部分被舍弃:', )
386     # float_arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
387     # int_arr = float_arr.astype(dtype=np.int)
388     # print(int_arr)
389     # print('\n使用astype把字符串转换为数组,如果失败抛出异常:')
390     # str_arr = np.array(['1.25', '-9.6', '42'], dtype=np.string_)
391     # float_arr = str_arr.astype(dtype=np.float)
392     # print(float_arr)
393     # print('\n astype使用其它数组的数据类型作为参数:')
394     # int_arr = np.arange(10)
395     # float_arr = np.array([.23, 0.270, .357, 0.44, 0.5], dtype=np.float64)
396     # print(int_arr.astype(float_arr.dtype))
397     # print('\n astype做了复制,数组本身不变:\n',int_arr[0], int_arr[1])
398         #
399 
400 
401     # print('数组乘法/减法,对应元素相乘/相减。')
402     # arr = np.array([[1.0, 2.0, 3.0], [4., 5., 6.]])
403     # print('>>>1\n',arr * arr)
404     # print('>>>2\n',arr - arr)
405     # print('\n 标量操作作用在数组的每个元素上 :')
406     # arr = np.array([[1.0, 2.0, 3.0], [4., 5., 6.]])
407     # print('>>>3\n',  1 / arr )
408     # print('>>>4\n', arr ** 0.5)      # 开根号
409         #
410 
411 
412     # print('\n通过索引访问二维数组某一行或某个元素')
413     # arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
414     # print(arr[2])
415     # print(arr[1][2])
416     # print(arr[1,2])
417     # print('\n对更高维数组的访问和操作')
418     # arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
419     # print('>>>1\n', arr[0])
420     # print('>>>2\n', arr[1, 0])
421     # old_values = arr[0].copy()        # 复制arr[0]的值
422     # arr[0] = 123456                   # 把  arr[0]所有的元素都设置为同一个值
423     # print('>>>3\n', arr)
424     # arr[0] = old_values               # 把原来的数组写回去
425     # print('>>>4\n', arr)
426     # print('\n 使用切片访问和操作数组:')
427     # arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
428     # print('>>>1\n',arr[1:6])          # 打印元素arr[1]到arr[5]
429     # arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
430     # print('>>>2\n', arr[:2])          # 打印第1、2行
431     # print('>>>3\n', arr[:2, 1:])      # 打印第1、2行,第2、3列
432     # print('>>>4\n',arr[:, :1])        # 打印第一列的所有元素
433     # arr[:2, 1:] = 0                   # 第1、2行,第2、3列的元素设置为0
434     # print('>>>5\n', arr)
435         #
436 
437 
438     # print('使用布尔数组作为索引')
439     # name_arr = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
440     # rnd_arr = np_random.randn(7, 4)                   # 随机7*4数组
441     # print('>>>1\n', rnd_arr)
442     # print('>>>2\n', name_arr == 'Bob')                # 返回布尔数组,元素等于'Bob'为True,否则False。
443     # print('>>>3\n', rnd_arr[name_arr == 'Bob'])       # 利用布尔数组选择行
444     # print('>>>4\n', rnd_arr[name_arr == 'Bob', :2])   # 增加限制打印列的范围
445     # print('>>>5\n', rnd_arr[~(name_arr == 'Bob')] )   # 对布尔数组的内容取反
446     # mask_arr = (name_arr == 'Bob') | (name_arr == 'Will')
447     # print('>>>6\n', rnd_arr[mask_arr])                # 逻辑运算混合结果
448     # rnd_arr[name_arr != 'Joe'] = 7
449     # print('>>>7\n', rnd_arr)                          # 先布尔数组选择行,然后把每行的元素设置为7
450         #
451 
452 
453     # print("\n 使用整数数组作为索引:")
454     # arr = np.empty((8, 4))
455     # for i in range(8):
456     #     arr[i] = i
457     # print('>>>1\n', arr)
458     # print('>>>2\n', arr[[4, 3, 0, 6]])          # 打印arr[4]、arr[3]、arr[0]和arr[6]
459     # print('>>>3\n', arr[[-3, -5, -7]])          # 打印arr[3]、arr[5]和arr[-7]行
460     # arr = np.arange(32).reshape((8, 4))         # 通过reshape变换成二维数组
461     # print('>>>4\n', arr)
462     # print('>>>5\n', arr[[1, 5, 7, 2], [0, 3, 1, 2]])          # 打印arr[1, 0]、arr[5, 3],arr[7, 1]和arr[2, 2]
463     # print('>>>6\n', arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]])       # 1572行的0312列
464     # print('>>>7\n', arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])] ) # 可读性更好的写法
465         #
466 
467 
468     # print("\n 转置矩阵")
469     # arr = np.arange(15).reshape((3, 5))
470     # print('>>>1\n', arr)
471     # print('>>>2\n', arr.T)
472     # print("\n 转置矩阵做点积")
473     # arr = np_random.randn(6, 3)
474     # print('>>>3\n', np.dot(arr.T, arr))
475     # print("\n 高维矩阵转换")
476     # arr = np.arange(16).reshape((2, 2, 4))
477     # print('>>>4\n', arr)
478     # print('>>>5\n', arr.transpose((1, 0, 2)))
479     # print('>>>6\n', arr.swapaxes(1, 2))
480     # print('>>>7\n', arr)
481     # '''
482     # 详细解释:
483     # arr数组的内容为
484     # - a[0][0] = [0, 1, 2, 3]
485     # - a[0][1] = [4, 5, 6, 7]
486     # - a[1][0] = [8, 9, 10, 11]
487     # - a[1][1] = [12, 13, 14, 15]
488     # transpose的参数为坐标,正常顺序为(0, 1, 2, ... , n - 1),
489     # 现在传入的为(1, 0, 2)代表a[x][y][z] = a[y][x][z],第0个和第1个坐标互换。
490     # - a'[0][0] = a[0][0] = [0, 1, 2, 3]
491     # - a'[0][1] = a[1][0] = [8, 9, 10, 11]
492     # - a'[1][0] = a[0][1] = [4, 5, 6, 7]
493     # - a'[1][1] = a[1][1] = [12, 13, 14, 15]
494     # '''
495         #
496 
497     # print("\n 求平方根")
498     # arr = np.arange(10)
499     # print('>>>1\n', arr)
500     # print('>>>2\n', np.sqrt(arr))
501     # print("\n 数组比较")
502     # x = np_random.randn(8)
503     # print(x)
504     # y = np_random.randn(8)
505     # print(y)
506     # print('>>>3\n', np.maximum(x, y))
507     # print("\n 使用modf函数把浮点数分解成整数和小数部分")
508     # arr = np_random.randn(7) * 5  # 统一乘5
509     # print('>>>4\n', np.modf(arr))
510         #
511 
512 
513     # points = np.arange(-10, 10, 0.005)    # 生成100个点
514     # xs, ys = np.meshgrid(points, points)  # xs, ys互为转置矩阵
515     # # print('>>>1\n', xs, ys)
516     # z = np.sqrt(xs ** 2 + ys ** 2)
517     # # print (z)
518     # print("\n 画图 ")
519     # plt.imshow(z, cmap = plt.cm.gray)#gray
520     # plt.colorbar()
521     # # plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")
522     # pylab.show()
523         #
524 
525 
526     # '''
527     # 关于zip函数的一点解释,zip可以接受任意多参数,然后重新组合成1个tuple列表。
528     # zip([1, 2, 3], [4, 5, 6], [7, 8, 9])
529     # 返回结果:[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
530     # '''
531     # print("\n通过真值表选择元素")
532     # x_arr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
533     # y_arr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
534     # cond = np.array([True, False, True, True, False])
535     # result = [(x if c else y) for x, y, c in zip(x_arr, y_arr, cond)]  # 通过列表推到实现
536     # print('>>>1\n', result)
537     # print('>>>2\n', np.where(cond, x_arr, y_arr))  # 使用NumPy的where函数
538     # arr = np_random.randn(4, 4)
539     # print('>>>3\n', arr)
540     # print('>>>4\n', np.where(arr > 0, 2, -2))
541     # print('>>>5\n', np.where(arr > 0, 2, arr))
542     # print("\n where嵌套")
543     # cond_1 = np.array([True, False, True, True, False])
544     # cond_2 = np.array([False, True, False, True, False])
545     # result = []
546     # for i in range(len(cond)):
547     #     if cond_1[i] and cond_2[i]:
548     #         result.append(0)
549     #     elif cond_1[i]:
550     #         result.append(1)
551     #     elif cond_2[i]:
552     #         result.append(2)
553     #     else:
554     #         result.append(3)
555     # print('>>>6\n', result)
556     # result = np.where(cond_1 & cond_2, 0,np.where(cond_1, 1, np.where(cond_2, 2, 3)))
557     # print('>>>7\n', result)
558         #
559 
560     # print("\n 求和,求平均:")
561     # arr = np.random.randn(5, 5)
562     # print('>>>1\n', arr)
563     # print('>>>2\n', arr.mean())             # 算术平均数
564     # print('>>>3\n', arr.sum())              # 对数组中全部或某轴向的元素求和
565     # print('>>>4\n', arr.mean(axis=1))       # 对每一行的元素求平均
566     # print('>>>5\n', arr.sum(0))             # 对每一列元素求和,axis可以省略
567     # '''
568     # cumsum:
569     #     - 按列操作:a[i][j] += a[i - 1][j]
570     #     - 按行操作:a[i][j] *= a[i][j - 1]
571     # cumprod:
572     #     - 按列操作:a[i][j] += a[i - 1][j]
573     #     - 按行操作:a[i][j] *= a[i][j - 1]
574     # '''
575     # print("\n cunsum和cumprod函数演示")
576     # arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
577     # print('>>>6\n', arr.cumsum(1))
578     # print('>>>7\n', arr.cumprod(1))
579     # print('>>>8\n', arr)
580     # print('>>>9\n', arr.cumsum(0))
581         #
582 
583 
584     # print("\n 对正数求和")
585     # arr = np_random.randn(100)
586     # print((arr > 0).sum())
587     # print("\n 对数组逻辑操作")
588     # bools = np.array([False, False, True, False])
589     # print( bools.any())     # 有一个为True则返回True
590     # print( bools.all())      # 有一个为False则返回False
591         #
592 
593 
594     # print("\n 一维数组排序")
595     # arr = np_random.randn(20)
596     # arr1 = arr.sort()
597     # print('>>>1\n', arr1)
598     # print("\n 二维数组排序")
599     # arr = np_random.randn(5, 5)
600     # arr2 = arr.sort(1)
601     # print('>>>3\n', arr2)        # 对每一行元素做排序
602     # arr3 = arr.sort(0)
603     # print('>>>4\n', arr3)
604     # print("\n 找位置在5%的数字")
605     # large_arr = np_random.randn(1000)
606     # large_arr.sort()
607     # print('>>>5\n', large_arr[int(0.05 * len(large_arr))])
608         #
609 
610     # print( '\n 用unique函数去重')
611     # names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
612     # print('>>>1\n', sorted(set(names)))       # 传统Python做法
613     # print('>>>2\n', np.unique(names))
614     # ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
615     # print('>>>3\n', np.unique(ints))
616     # print('\n查找数组元素是否在另一数组')
617     # values = np.array([6, 0, 0, 3, 2, 5, 6])
618     # print('>>>4\n', np.in1d(values, [2, 3, 6]))
619         #
620 
621     # 此部分能生成文件 文件名开头 test
622     # print( '\n 数组文件读写 : ')
623     # arr = np.arange(10)
624     # np.save('test_some_array', arr)
625     # print(np.load('test_some_array.npy'))
626     # print( '\n 多个数组压缩存储')
627     # np.savez('test_array_archive.npz', a=arr, b=arr)
628     # arch = np.load('test_array_archive.npz')
629     # print(arch['b'])
630     #     # 读取文件注释
631     # print('\n 读取csv文件做为数组')
632     # arr = np.loadtxt('array_ex.txt', delimiter=',')
633     # print(arr)
634         #
635 
636     # print( '\n 矩阵乘法')
637     # x = np.array([[1., 2., 3.], [4., 5., 6.]])
638     # y = np.array([[6., 23.], [-1, 7], [8, 9]])
639     # print('>>>1\n', x.dot(y))                   # 矩阵乘法
640     # print('>>>2\n', np.dot(x, np.ones(3)))
641     # x = np_random.randn(5, 5)
642     # print('>>>3\n', x)
643     # print('矩阵求逆')
644     # mat = x.T.dot(x)
645     # print( '>>>4\n', inv(mat))             # 矩阵求逆
646     # print( '>>>5\n', mat.dot(inv(mat)))    # 与逆矩阵相乘,得到单位矩阵。
647     # print( '矩阵消元')
648     # print('>>>6\n', mat)
649     # q, r = qr(mat)
650     # print('>>>7\n', q)
651     # print('>>>8\n', r)
652         #
653 
654     # print("\n正态分布随机数:")
655     # samples = np.random.normal(size=(5, 5))
656     # print('>>>1\n', samples)
657     # print("\n批量按正态分布生成0到1的随机数")
658     # N = 10
659     # print([normalvariate(0, 10)for _ in range(N)])
660     # print(np.random.normal(size=N))                  # 与上面代码等价
661        #
662 
663 
664     # print("\n 将一维数组转换为二维数组")
665     # arr = np.arange(8)
666     # print('>>>1\n', arr.reshape((4, 2)))
667     # print('>>>2\n', arr.reshape((4, 2)).reshape((2, 4)))        # 支持链式操作
668     # print("\n 维度大小自动推导")
669     # arr = np.arange(54)
670     # print('>>>3\n', arr.reshape((9, -1)))
671     # print("\n 获取维度信息并应用")
672     # other_arr = np.ones((6, 9))
673     # print('>>>4\n', other_arr.shape)
674     # print('>>>5\n', arr.reshape(other_arr.shape))
675     # print("\n 高维数组拉平")
676     # arr = np.arange(15).reshape((5, 3))
677     # print('>>>6\n', arr.ravel())
678         #
679 
680 
681     # print("\n ")
682     # print("\n 连接两个二维数组 ")
683     # arr1 = np.array([[1, 2, 3], [4, 5, 6]])
684     # arr2 = np.array([[7, 8, 9], [10, 11, 12]])
685     # print('>>>1\n', np.concatenate([arr1, arr2], axis=0))       # 按行连接
686     # print('>>>2\n', np.concatenate([arr1, arr2], axis=1))       # 按列连接
687     # print("\n 垂直stack与水平stack")
688     # print('>>>3\n', np.vstack((arr1, arr2)))                    # 垂直堆叠
689     # print('>>>4\n', np.hstack((arr1, arr2)) )                   # 水平堆叠
690     # print("\n 拆分数组")
691     # arr = np_random.randn(5, 5)
692     # print("\n 水平拆分")
693     # first, second, third = np.split(arr, [1, 3], axis=0)
694     # print('>>>5\n', first)
695     # print('>>>6\n', second)
696     # print('>>>7\n', third)
697     # print("\n 垂直拆分")
698     # first, second, third = np.split(arr, [1, 3], axis=1)
699     # print('>>>8\n', first)
700     # print('>>>9\n', second)
701     # print('>>>10\n', third)
702     # print("\n 堆叠辅助类")
703     # arr = np.arange(6)
704     # arr1 = arr.reshape((3, 2))
705     # arr2 = np_random.randn(3, 2)
706     # print("\n r_用于按行堆叠")
707     # print('>>>11\n', np.r_[arr1, arr2])
708     # print("\n c_用于按列堆叠")
709     # print('>>>12\n', np.c_[np.r_[arr1, arr2], arr])
710     # print('\n 切片直接转为数组')
711     # print('>>>13\n', np.c_[1:6, -10:-5])
712         #
713     # try:
714     #     print("\n ")
715     #     print("\n Repeat: 按元素")
716     #     arr = np.arange(4)
717     #     print('>>>1\n', arr.repeat([1, 2, 3, 4]))      # 3个元素,分别复制2, 3, 4次。长度要匹配
718     #     print("\n Repeat,指定轴")
719     #     arr = np_random.randn(3, 3)
720     #     print('>>>2\n', arr)
721     #     print('>>>3\n', arr.repeat(2, axis=0))           # 按行repeat
722     #     print('>>>4\n', arr.repeat(2, axis=1))           # 按列repeat
723     #     print('>>>5\n', arr.repeat(2, axis=0))           # 按行repeat
724     #     print("\n Tile: 参考贴瓷砖")
725     #     arr = np_random.randn(2, 2)
726     #     print('>>>6\n', np.tile(arr, 2))
727     #     print('>>>7\n', np.tile(arr, (2, 3)) )           # 指定每个轴的tile次数
728     # except Exception:
729     #     print("出问题!!!")
730 
731     # try:
732     #     print("\n Fancy Indexing例子代码")
733     #     arr = np.arange(10) * 100
734     #     print(arr)
735     #     inds = [7, 1, 2, 6]
736     #     print('>>>1\n', arr[inds])
737     #     print("\n 使用take")
738     #     print('>>>2\n', arr.take(inds))
739     #     print("\n 使用put更新内容")
740     #     print('>>>3\n', arr.put(inds, 50))
741     #     print('>>>4\n', arr)
742     #     print('>>>5\n', arr.put(inds, [70, 10, 20, 60]))
743     #     print('>>>6\n', arr)
744     #     print("\n take指定轴")
745     #     arr = np_random.randn(2, 4)
746     #     inds = [2, 0, 2, 1]
747     #     print('>>>7\n', arr)
748     #     print('>>>8\n', arr.take(inds, axis=1))
749     # except Exception:
750     #     print("出问题!!!")
751 
752 
753     try:
754         print("\n 模拟随机游走:")
755         nsteps = 1000
756         draws = np.random.randint(0, 2, size=nsteps)
757         steps = np.where(draws > 0, 1, -1)
758         walk = steps.cumsum()
759         print("画图")
760         plt.title('Random Walk')
761         limit = max(abs(min(walk)), abs(max(walk)))
762         plt.axis([0, nsteps, -limit, limit])
763         x = np.linspace(0, nsteps, nsteps)
764         plt.plot(x, walk, 'g-')
765         plt.show()
766     except Exception:
767         print("出问题!!!")
768     # print('>>>1\n', )
769     # print('>>>2\n', )
770     # print('>>>3\n', )
771     # print('>>>4\n', )
772     # print('>>>5\n', )
773     # print('>>>6\n', )
774     # print('>>>7\n', )
775     # print('>>>8\n', )
776     # print('>>>9\n', )

 

--------

---------------------------------------------------------------------------

posted @ 2018-11-28 19:12  楚格  阅读(203)  评论(0编辑  收藏  举报