10.2353102210.7226722211.2332403311.7681195212.32846739 12.9154966513.5304777514.17474163 14.8496826215.55676144 16.2975 83517.0735 17.886 520 18.7381 19.630406 20.56512308 21.5443 6 22.5701972 23.64489413 24.7707635 25.9502421127.1858824328.4803586829.8364724 31.2571585 32.7454916334.3046928635.9381366437.6493580739.44206059 41.320124 43.2876128145.3487850847.5081016249.77023564 52140082885462277 21857.2236765959.9484250362.80291442 65.79332 68.9261210 72.20809018 75.64633276 79.2482898 83.0217568186.9749002691.1162756195.45484567100. 等比数列中，可以指定底数的方式来进行，比如，可以指定2为底数，程序如下： import numpy as np Test np.logspace(0,1,12,base=2,endpoint False) print(Test) 输出的结果： 1.059463091.122462051.189207121.259921051.33483985 1.414213561.498307081.587401051.681792831.781797441.88774863 如果只是给数据分配空间，而不赋值的话，可以采用empty import numpy as np A=np.empty((1,2,3),dtype=np.int32) print(A) 输出的结果： [f1684300816843009168430091 [168430091684300916843009111 如果是赋给0的情祝，可以采用zeros import numpy as np B=np.zeros((5,),dtype=int) print(B) 输出结果： 100000 如果是赋值为1，可以采用ones import numpy as np C=np.ones((2,3),dtype int) nrint(c) 输出的结果： 111 11] 如果用指定的元素来进行初始化，就用fu import numpy as np
10.23531022 10.72267222 11.23324033 11.76811952 12.32846739 12.91549665 13.53047775 14.17474163 14.84968262 15.55676144 16.29750835 17.07352647 17.88649529 18.73817423 19.6304065 20.56512308 21.5443469 22.5701972 23.64489413 24.77076356 25.95024211 27.18588243 28.48035868 29.8364724 31.2571585 32.74549163 34.30469286 35.93813664 37.64935807 39.44206059 41.320124 43.28761281 45.34878508 47.50810162 49.77023564 52.14008288 54.62277218 57.22367659 59.94842503 62.80291442 65.79332247 68.92612104 72.20809018 75.64633276 79.24828984 83.02175681 86.97490026 91.11627561 95.45484567 100. ] 等比数列中，可以指定底数的方式来进行，比如，可以指定 2 为底数，程序如下： import numpy as np Test = np.logspace(0,1,12,base=2,endpoint = False) print(Test) 输出的结果： [1. 1.05946309 1.12246205 1.18920712 1.25992105 1.33483985 1.41421356 1.49830708 1.58740105 1.68179283 1.78179744 1.88774863] 如果只是给数据分配空间，而不赋值的话，可以采用 empty import numpy as np A = np.empty((1,2,3),dtype = np.int32) print(A) 输出的结果： [[[16843008 16843009 16843009] [16843009 16843009 16843009]]] 如果是赋给 0 的情况，可以采用 zeros import numpy as np B = np.zeros((5,),dtype = int) print(B) 输出结果： [0 0 0 0 0] 如果是赋值为 1，可以采用 ones import numpy as np C = np.ones((2,3),dtype = int) print(C) 输出的结果： [[1 1 1] [1 1 1]] 如果用指定的元素来进行初始化，就用 full import numpy as np
D=np.full(4.np.pi) print(D) 输出的结果： [3.141592653.141592653.141592653.14159265】 Fromstrine将字符转换为数组 import numpy as np s="abcd" A=np.fromstring(s,dtype=np.int8) B=np.fromstring(s,dtype np.int16) C=np.fromstring(s,dtype=np.int32) print(A) print(B) int(C 输出的结果： 【979899100] I25185256991 [16842348491 注意：fromstring(0会对字符串的字节序列进行复制，而使用frombuffer创建的数组与原始宁 符串共享内存。由于字符串是只读的，因此无法修改所创建的数组的内容。 可以先定义一个下标计算数值的函数，然后用fromfunction通过此函数创建数组： mpy as np return (i+1)"(j+1) A=np.fromfunction(func,(9,9)) print(A) 这种方法就可以打印一个乘法表了。 存取元素 可以使用和列表相同的方式对数组的元素进行存取： 如果是一维的话，我们可以这样来操作元素 import numpy asnp A=np.arange(0,10,1) print(A) print(A[3:8]) print(A[3:8:2]) 输出的结果： 0123456789 [34567刀 357刃 如果直接使用每个元素的下标，可以这样来操作元素：
D = np.full( 4,np.pi) print(D) 输出的结果： [3.14159265 3.14159265 3.14159265 3.14159265] Fromstring 将字符转换为数组 import numpy as np s = "abcd" A = np.fromstring(s,dtype=np.int8) B = np.fromstring(s,dtype = np.int16) C = np.fromstring(s,dtype = np.int32) print(A) print(B) print(C) 输出的结果： [ 97 98 99 100] [25185 25699] [1684234849] 注意：fromstring()会对字符串的字节序列进行复制，而使用 frombuffer 创建的数组与原始字 符串共享内存。由于字符串是只读的，因此无法修改所创建的数组的内容。 可以先定义一个下标计算数值的函数，然后用 fromfunction 通过此函数创建数组: import numpy as np def func(i,j): return (i + 1)*(j+1) A = np.fromfunction(func,(9,9)) print(A) 这种方法就可以打印一个乘法表了。 存取元素 可以使用和列表相同的方式对数组的元素进行存取： 如果是一维的话，我们可以这样来操作元素 import numpy as np A = np.arange(0,10,1) print(A) print(A[3:8]) print(A[3:8:2]) 输出的结果： [0 1 2 3 4 5 6 7 8 9] [3 4 5 6 7] [3 5 7] 如果直接使用每个元素的下标，可以这样来操作元素：
import numpy as np A=np.arange(0,10,1) print(A) print(A3,8-2,-1,9jl) 输出的结果： [01234567891 [388991 如果是对多维数组的操作，那情况如何呢？因为多维数组的存取和一维数组类似，因为多维 数组有多个轴，所以它的下标需要用多个值来表示。 Numpy使用元组作为下标来存储数据，所以元组的模式有显性和隐形两种形式。 import numpy as np A=np. ray1,23,41.56,7,8 B=A[1,2 C=A[(1,2)] print(A) print(B) print(C) 输出的结果： 1234 5678 7 7 采用sc切片对象，可以使用目号隔开的两个或三个整数表示切片，但是单独生成切片对 象时需要使用sice来创建。 import numpy as np A=np.array([[1,2,3,41,5,6,7,8) B=Ae:2,2 print(A) print(B) 注意：[2,2 Slice(None,None,2),slice(2,None,None) 输出的结果： 12341 5678 [34 结构数组：可以首先定义一个结构数组，它的每个元素都有name,age和weight import numpy as np Person=np.dtype( 'names':['name,'ageweight'], "formats':['S30',i',f]),align True) a np.array([('wan'44.72).('jun',35.67)1.dtype Person)
import numpy as np A = np.arange(0,10,1) print(A) print(A[[3,8,-2,-1,9]]) 输出的结果： [0 1 2 3 4 5 6 7 8 9] [3 8 8 9 9] 如果是对多维数组的操作，那情况如何呢？因为多维数组的存取和一维数组类似，因为多维 数组有多个轴，所以它的下标需要用多个值来表示。 Numpy 使用元组作为下标来存储数据，所以元组的模式有显性和隐形两种形式。 import numpy as np A = np.array([[1,2,3,4],[5,6,7,8]]) B = A[1,2] C = A[(1,2)] print(A) print(B) print(C) 输出的结果： [[1 2 3 4] [5 6 7 8]] 7 7 采用 slice 切片对象，可以使用冒号隔开的两个或三个整数表示切片，但是单独生成切片对 象时需要使用 slice 来创建。 import numpy as np A = np.array([[1,2,3,4],[5,6,7,8]]) B = A[::2,2:] print(A) print(B) 注意：[::2,2:] Slice(None,None,2),slice(2,None,None) 输出的结果： [[1 2 3 4] [5 6 7 8]] [[3 4]] 结构数组：可以首先定义一个结构数组，它的每个元素都有 name，age 和 weight import numpy as np Person = np.dtype({ 'names':['name','age','weight'], 'formats':['S30','i','f']},align = True) a = np.array([('wan',44,72),('jun',35,67)],dtype = Person)
print(a) 输出的结果 [(bwan,44,72)(bjun,35,67. 说明：首先是创建一个自定义类型，然后使用这个自定义的类型来完成构建过程。 矩阵的分布及计算 E神经网 路中 我们经常需要用到的是三种分布，正态，均匀，泊松。通常需要的计算为求 和，平均值，方差 首先看看三种分布的实现： import numpy as np from numpy import random as nr np.set_printoptions(precision=2) r1 nr.rand(4,3) r2 nr.randn(4,3 r3 nr.randint(0.10.(4.3)) print(r1) print(r2) print(r3) print('- r4=nm.normall(100.10.(4,3 r5=nr.uniform(10,20,(4,3)) r6=nr.poisson(2.0.(4,3) print(r4) print(r5) print(r6) 输出的结果： 0.430.240.84 0.830.7 [0.380.170.631 10.950.420.161 [-1.14-2.951.13 11.73-108-0.571 -0.13 0.110.07 10.68 1.430.31 2351 [383] 0371 846 99.7791.6685.79 [111.85108.0299.72)
print(a) 输出的结果： [(b'wan', 44, 72.) (b'jun', 35, 67.)] 说明：首先是创建一个自定义类型，然后使用这个自定义的类型来完成构建过程。 矩阵的分布及计算 在神经网络中，我们经常需要用到的是三种分布，正态，均匀，泊松。通常需要的计算为求 和，平均值，方差。 首先看看三种分布的实现： import numpy as np from numpy import random as nr np.set_printoptions(precision = 2) r1 = nr.rand(4,3) r2 = nr.randn(4,3) r3 = nr.randint(0,10,(4,3)) print(r1) print(r2) print(r3) print('------------------') r4 = nr.normal(100,10,(4,3)) r5 = nr.uniform(10,20,(4,3)) r6 = nr.poisson(2.0,(4,3)) print(r4) print(r5) print(r6) 输出的结果： [[0.43 0.24 0.84] [0.4 0.83 0.77] [0.38 0.17 0.63] [0.95 0.42 0.16]] [[-1.14 -2.95 1.13] [ 1.73 -1.08 -0.57] [-0.13 0.11 -0.07] [ 0.68 1.43 0.3 ]] [[2 3 5] [3 8 3] [0 3 7] [8 4 6]] ------------------ [[ 99.77 91.66 85.79] [111.85 108.02 99.72]
[97.75102.4189.561 【96.0991.94113.23 19.4517.2710.791 [15.8915.5515.37 [19.2510.4612.51 [19.8814.5318.471 t3211 0311 [221 [264]1 Permutation可以用来产生一个乱序数组。 mport numpy as np from numpy import random as n A=np.array([10,20,30,40]) B=nr.permutation(A) print(A) brint() 输出的结果 【102030401 [301020401 注意：permutation返回一个新数组，而shuffle()直接将参数数组的顺序打乱 import numpy as np from numpy import random as nr A np.array([10,20,30,40]) B=nr.permutation(A) C=nr.shuffle(A) print(A) print(B) print(C) 输出的结果： 1402030101 [20301040 None Choice从指定的样本中随机进行抽取， import numpy as np from numpy import random asnr A=np.array([10,20,30,40, 0 D=nr.choice(A,size=(4,3)) print(D) 输出的结果：
[ 97.75 102.41 89.56] [ 96.09 91.94 113.23]] [[19.45 17.27 10.79] [15.89 15.55 15.37] [19.25 10.46 12.5 ] [19.88 14.53 18.47]] [[3 2 1] [0 3 1] [2 2 1] [2 6 4]] Permutation 可以用来产生一个乱序数组。 import numpy as np from numpy import random as nr A = np.array([10,20,30,40]) B = nr.permutation(A) print(A) print(B) 输出的结果: [10 20 30 40] [30 10 20 40] 注意：permutation 返回一个新数组，而 shuffle（）直接将参数数组的顺序打乱。 import numpy as np from numpy import random as nr A = np.array([10,20,30,40]) B = nr.permutation(A) C = nr.shuffle(A) print(A) print(B) print(C) 输出的结果： [40 20 30 10] [20 30 10 40] None Choice 从指定的样本中随机进行抽取。 import numpy as np from numpy import random as nr A = np.array([10,20,30,40,50]) D = nr.choice(A,size=(4,3)) print(D) 输出的结果：