zoukankan      html  css  js  c++  java
  • 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, '
     打印数组维度: ',arr.shape)                   # 打印数组维度
    369     # print('使用zeros/empty')
    370     # print('
    生成10个0的一维数组: 
     ',np.zeros(10))              # 生成包含10个0的一维数组
    371     # print('
    生成3*6的二维数组: 
     ', np.zeros((3, 6)))           # 生成3*6的二维数组
    372     # print('
    生成2*3*2的三维数组,元素未初始化: 
    ',np.empty((2, 3, 2)))   # 生成2*3*2的三维数组,所有元素未初始化
    373     # print('
    生成连续元素: 
    ', np.arange(15))
    374         #
    375 
    376 
    377     # print('
    生成数组时指定数据类型:',)
    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('
     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('
     使用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('
    使用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('
     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('
     astype做了复制,数组本身不变:
    ',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
    ',arr * arr)
    404     # print('>>>2
    ',arr - arr)
    405     # print('
     标量操作作用在数组的每个元素上 :')
    406     # arr = np.array([[1.0, 2.0, 3.0], [4., 5., 6.]])
    407     # print('>>>3
    ',  1 / arr )
    408     # print('>>>4
    ', arr ** 0.5)      # 开根号
    409         #
    410 
    411 
    412     # print('
    通过索引访问二维数组某一行或某个元素')
    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('
    对更高维数组的访问和操作')
    418     # arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
    419     # print('>>>1
    ', arr[0])
    420     # print('>>>2
    ', arr[1, 0])
    421     # old_values = arr[0].copy()        # 复制arr[0]的值
    422     # arr[0] = 123456                   # 把  arr[0]所有的元素都设置为同一个值
    423     # print('>>>3
    ', arr)
    424     # arr[0] = old_values               # 把原来的数组写回去
    425     # print('>>>4
    ', arr)
    426     # print('
     使用切片访问和操作数组:')
    427     # arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    428     # print('>>>1
    ',arr[1:6])          # 打印元素arr[1]到arr[5]
    429     # arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    430     # print('>>>2
    ', arr[:2])          # 打印第1、2行
    431     # print('>>>3
    ', arr[:2, 1:])      # 打印第1、2行,第2、3列
    432     # print('>>>4
    ',arr[:, :1])        # 打印第一列的所有元素
    433     # arr[:2, 1:] = 0                   # 第1、2行,第2、3列的元素设置为0
    434     # print('>>>5
    ', 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
    ', rnd_arr)
    442     # print('>>>2
    ', name_arr == 'Bob')                # 返回布尔数组,元素等于'Bob'为True,否则False。
    443     # print('>>>3
    ', rnd_arr[name_arr == 'Bob'])       # 利用布尔数组选择行
    444     # print('>>>4
    ', rnd_arr[name_arr == 'Bob', :2])   # 增加限制打印列的范围
    445     # print('>>>5
    ', rnd_arr[~(name_arr == 'Bob')] )   # 对布尔数组的内容取反
    446     # mask_arr = (name_arr == 'Bob') | (name_arr == 'Will')
    447     # print('>>>6
    ', rnd_arr[mask_arr])                # 逻辑运算混合结果
    448     # rnd_arr[name_arr != 'Joe'] = 7
    449     # print('>>>7
    ', rnd_arr)                          # 先布尔数组选择行,然后把每行的元素设置为7
    450         #
    451 
    452 
    453     # print("
     使用整数数组作为索引:")
    454     # arr = np.empty((8, 4))
    455     # for i in range(8):
    456     #     arr[i] = i
    457     # print('>>>1
    ', arr)
    458     # print('>>>2
    ', arr[[4, 3, 0, 6]])          # 打印arr[4]、arr[3]、arr[0]和arr[6]
    459     # print('>>>3
    ', arr[[-3, -5, -7]])          # 打印arr[3]、arr[5]和arr[-7]行
    460     # arr = np.arange(32).reshape((8, 4))         # 通过reshape变换成二维数组
    461     # print('>>>4
    ', arr)
    462     # print('>>>5
    ', arr[[1, 5, 7, 2], [0, 3, 1, 2]])          # 打印arr[1, 0]、arr[5, 3],arr[7, 1]和arr[2, 2]
    463     # print('>>>6
    ', arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]])       # 1572行的0312列
    464     # print('>>>7
    ', arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])] ) # 可读性更好的写法
    465         #
    466 
    467 
    468     # print("
     转置矩阵")
    469     # arr = np.arange(15).reshape((3, 5))
    470     # print('>>>1
    ', arr)
    471     # print('>>>2
    ', arr.T)
    472     # print("
     转置矩阵做点积")
    473     # arr = np_random.randn(6, 3)
    474     # print('>>>3
    ', np.dot(arr.T, arr))
    475     # print("
     高维矩阵转换")
    476     # arr = np.arange(16).reshape((2, 2, 4))
    477     # print('>>>4
    ', arr)
    478     # print('>>>5
    ', arr.transpose((1, 0, 2)))
    479     # print('>>>6
    ', arr.swapaxes(1, 2))
    480     # print('>>>7
    ', 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("
     求平方根")
    498     # arr = np.arange(10)
    499     # print('>>>1
    ', arr)
    500     # print('>>>2
    ', np.sqrt(arr))
    501     # print("
     数组比较")
    502     # x = np_random.randn(8)
    503     # print(x)
    504     # y = np_random.randn(8)
    505     # print(y)
    506     # print('>>>3
    ', np.maximum(x, y))
    507     # print("
     使用modf函数把浮点数分解成整数和小数部分")
    508     # arr = np_random.randn(7) * 5  # 统一乘5
    509     # print('>>>4
    ', 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
    ', xs, ys)
    516     # z = np.sqrt(xs ** 2 + ys ** 2)
    517     # # print (z)
    518     # print("
     画图 ")
    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("
    通过真值表选择元素")
    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
    ', result)
    537     # print('>>>2
    ', np.where(cond, x_arr, y_arr))  # 使用NumPy的where函数
    538     # arr = np_random.randn(4, 4)
    539     # print('>>>3
    ', arr)
    540     # print('>>>4
    ', np.where(arr > 0, 2, -2))
    541     # print('>>>5
    ', np.where(arr > 0, 2, arr))
    542     # print("
     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
    ', result)
    556     # result = np.where(cond_1 & cond_2, 0,np.where(cond_1, 1, np.where(cond_2, 2, 3)))
    557     # print('>>>7
    ', result)
    558         #
    559 
    560     # print("
     求和,求平均:")
    561     # arr = np.random.randn(5, 5)
    562     # print('>>>1
    ', arr)
    563     # print('>>>2
    ', arr.mean())             # 算术平均数
    564     # print('>>>3
    ', arr.sum())              # 对数组中全部或某轴向的元素求和
    565     # print('>>>4
    ', arr.mean(axis=1))       # 对每一行的元素求平均
    566     # print('>>>5
    ', 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("
     cunsum和cumprod函数演示")
    576     # arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
    577     # print('>>>6
    ', arr.cumsum(1))
    578     # print('>>>7
    ', arr.cumprod(1))
    579     # print('>>>8
    ', arr)
    580     # print('>>>9
    ', arr.cumsum(0))
    581         #
    582 
    583 
    584     # print("
     对正数求和")
    585     # arr = np_random.randn(100)
    586     # print((arr > 0).sum())
    587     # print("
     对数组逻辑操作")
    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("
     一维数组排序")
    595     # arr = np_random.randn(20)
    596     # arr1 = arr.sort()
    597     # print('>>>1
    ', arr1)
    598     # print("
     二维数组排序")
    599     # arr = np_random.randn(5, 5)
    600     # arr2 = arr.sort(1)
    601     # print('>>>3
    ', arr2)        # 对每一行元素做排序
    602     # arr3 = arr.sort(0)
    603     # print('>>>4
    ', arr3)
    604     # print("
     找位置在5%的数字")
    605     # large_arr = np_random.randn(1000)
    606     # large_arr.sort()
    607     # print('>>>5
    ', large_arr[int(0.05 * len(large_arr))])
    608         #
    609 
    610     # print( '
     用unique函数去重')
    611     # names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
    612     # print('>>>1
    ', sorted(set(names)))       # 传统Python做法
    613     # print('>>>2
    ', np.unique(names))
    614     # ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
    615     # print('>>>3
    ', np.unique(ints))
    616     # print('
    查找数组元素是否在另一数组')
    617     # values = np.array([6, 0, 0, 3, 2, 5, 6])
    618     # print('>>>4
    ', np.in1d(values, [2, 3, 6]))
    619         #
    620 
    621     # 此部分能生成文件 文件名开头 test
    622     # print( '
     数组文件读写 : ')
    623     # arr = np.arange(10)
    624     # np.save('test_some_array', arr)
    625     # print(np.load('test_some_array.npy'))
    626     # print( '
     多个数组压缩存储')
    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('
     读取csv文件做为数组')
    632     # arr = np.loadtxt('array_ex.txt', delimiter=',')
    633     # print(arr)
    634         #
    635 
    636     # print( '
     矩阵乘法')
    637     # x = np.array([[1., 2., 3.], [4., 5., 6.]])
    638     # y = np.array([[6., 23.], [-1, 7], [8, 9]])
    639     # print('>>>1
    ', x.dot(y))                   # 矩阵乘法
    640     # print('>>>2
    ', np.dot(x, np.ones(3)))
    641     # x = np_random.randn(5, 5)
    642     # print('>>>3
    ', x)
    643     # print('矩阵求逆')
    644     # mat = x.T.dot(x)
    645     # print( '>>>4
    ', inv(mat))             # 矩阵求逆
    646     # print( '>>>5
    ', mat.dot(inv(mat)))    # 与逆矩阵相乘,得到单位矩阵。
    647     # print( '矩阵消元')
    648     # print('>>>6
    ', mat)
    649     # q, r = qr(mat)
    650     # print('>>>7
    ', q)
    651     # print('>>>8
    ', r)
    652         #
    653 
    654     # print("
    正态分布随机数:")
    655     # samples = np.random.normal(size=(5, 5))
    656     # print('>>>1
    ', samples)
    657     # print("
    批量按正态分布生成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("
     将一维数组转换为二维数组")
    665     # arr = np.arange(8)
    666     # print('>>>1
    ', arr.reshape((4, 2)))
    667     # print('>>>2
    ', arr.reshape((4, 2)).reshape((2, 4)))        # 支持链式操作
    668     # print("
     维度大小自动推导")
    669     # arr = np.arange(54)
    670     # print('>>>3
    ', arr.reshape((9, -1)))
    671     # print("
     获取维度信息并应用")
    672     # other_arr = np.ones((6, 9))
    673     # print('>>>4
    ', other_arr.shape)
    674     # print('>>>5
    ', arr.reshape(other_arr.shape))
    675     # print("
     高维数组拉平")
    676     # arr = np.arange(15).reshape((5, 3))
    677     # print('>>>6
    ', arr.ravel())
    678         #
    679 
    680 
    681     # print("
     ")
    682     # print("
     连接两个二维数组 ")
    683     # arr1 = np.array([[1, 2, 3], [4, 5, 6]])
    684     # arr2 = np.array([[7, 8, 9], [10, 11, 12]])
    685     # print('>>>1
    ', np.concatenate([arr1, arr2], axis=0))       # 按行连接
    686     # print('>>>2
    ', np.concatenate([arr1, arr2], axis=1))       # 按列连接
    687     # print("
     垂直stack与水平stack")
    688     # print('>>>3
    ', np.vstack((arr1, arr2)))                    # 垂直堆叠
    689     # print('>>>4
    ', np.hstack((arr1, arr2)) )                   # 水平堆叠
    690     # print("
     拆分数组")
    691     # arr = np_random.randn(5, 5)
    692     # print("
     水平拆分")
    693     # first, second, third = np.split(arr, [1, 3], axis=0)
    694     # print('>>>5
    ', first)
    695     # print('>>>6
    ', second)
    696     # print('>>>7
    ', third)
    697     # print("
     垂直拆分")
    698     # first, second, third = np.split(arr, [1, 3], axis=1)
    699     # print('>>>8
    ', first)
    700     # print('>>>9
    ', second)
    701     # print('>>>10
    ', third)
    702     # print("
     堆叠辅助类")
    703     # arr = np.arange(6)
    704     # arr1 = arr.reshape((3, 2))
    705     # arr2 = np_random.randn(3, 2)
    706     # print("
     r_用于按行堆叠")
    707     # print('>>>11
    ', np.r_[arr1, arr2])
    708     # print("
     c_用于按列堆叠")
    709     # print('>>>12
    ', np.c_[np.r_[arr1, arr2], arr])
    710     # print('
     切片直接转为数组')
    711     # print('>>>13
    ', np.c_[1:6, -10:-5])
    712         #
    713     # try:
    714     #     print("
     ")
    715     #     print("
     Repeat: 按元素")
    716     #     arr = np.arange(4)
    717     #     print('>>>1
    ', arr.repeat([1, 2, 3, 4]))      # 3个元素,分别复制2, 3, 4次。长度要匹配
    718     #     print("
     Repeat,指定轴")
    719     #     arr = np_random.randn(3, 3)
    720     #     print('>>>2
    ', arr)
    721     #     print('>>>3
    ', arr.repeat(2, axis=0))           # 按行repeat
    722     #     print('>>>4
    ', arr.repeat(2, axis=1))           # 按列repeat
    723     #     print('>>>5
    ', arr.repeat(2, axis=0))           # 按行repeat
    724     #     print("
     Tile: 参考贴瓷砖")
    725     #     arr = np_random.randn(2, 2)
    726     #     print('>>>6
    ', np.tile(arr, 2))
    727     #     print('>>>7
    ', np.tile(arr, (2, 3)) )           # 指定每个轴的tile次数
    728     # except Exception:
    729     #     print("出问题!!!")
    730 
    731     # try:
    732     #     print("
     Fancy Indexing例子代码")
    733     #     arr = np.arange(10) * 100
    734     #     print(arr)
    735     #     inds = [7, 1, 2, 6]
    736     #     print('>>>1
    ', arr[inds])
    737     #     print("
     使用take")
    738     #     print('>>>2
    ', arr.take(inds))
    739     #     print("
     使用put更新内容")
    740     #     print('>>>3
    ', arr.put(inds, 50))
    741     #     print('>>>4
    ', arr)
    742     #     print('>>>5
    ', arr.put(inds, [70, 10, 20, 60]))
    743     #     print('>>>6
    ', arr)
    744     #     print("
     take指定轴")
    745     #     arr = np_random.randn(2, 4)
    746     #     inds = [2, 0, 2, 1]
    747     #     print('>>>7
    ', arr)
    748     #     print('>>>8
    ', arr.take(inds, axis=1))
    749     # except Exception:
    750     #     print("出问题!!!")
    751 
    752 
    753     try:
    754         print("
     模拟随机游走:")
    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
    ', )
    769     # print('>>>2
    ', )
    770     # print('>>>3
    ', )
    771     # print('>>>4
    ', )
    772     # print('>>>5
    ', )
    773     # print('>>>6
    ', )
    774     # print('>>>7
    ', )
    775     # print('>>>8
    ', )
    776     # print('>>>9
    ', )

    --------

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

  • 相关阅读:
    如何强制360浏览器以极速模式打开页面
    如何解决Android SDK无法下载Package的问题(.net)
    Xamarin 安装步骤
    使用require.js和backbone实现简单单页应用实践
    HBuilder之初体验
    ClassLoader&双亲委派&类初始化过程
    List remove ConcurrentModificationException源码分析
    二十九、简谈设计模式
    二十八、Java基础--------正则表达式
    二十七、JDK1.5新特性---Annotation
  • 原文地址:https://www.cnblogs.com/caochucheng/p/10034018.html
Copyright © 2011-2022 走看看