20道习题：练练手（附答案）

Logout 练习 Last Checkpoint: Last Monday at 5:57 PM (autosaved)

Python 3 

Trusted

• File
• Edit
• View
• Insert
• Cell
• Kernel
• Widgets
• Help

CodeMarkdownRaw NBConvertHeading-

1、创建一个长度为10的一维全为0的ndarray对象，然后让第5个元素等于1

In [6]:

import numpy as np 

np.__version__

Out[6]:

'1.13.1'

In [7]:

nd= np.array([0,0,0,0.0,0,0,0,0,0])

nd

Out[7]:

array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])

In [8]:

nd[4] = 5

nd

Out[8]:

array([ 0.,  0.,  0.,  0.,  5.,  0.,  0.,  0.,  0.])

2、创建一个元素为从10到49的ndarray对象

In [9]:

nd2=np.arange(10,49,5)

nd2

Out[9]:

array([10, 15, 20, 25, 30, 35, 40, 45])

3、将第2题的所有元素位置反转

In [10]:

nd3=nd2[::-1]

nd3

Out[10]:

array([45, 40, 35, 30, 25, 20, 15, 10])

4、使用np.random.random创建一个10*10的ndarray对象，并打印出最大最小元素

In [11]:

nd4=np.random.random((10,10)) # 生成0-1之间的浮点数

nd4

Out[11]:

array([[ 0.15764428,  0.71596328,  0.81808397,  0.81675306,  0.70382255,
         0.78524804,  0.21928811,  0.43166498,  0.49184857,  0.07405726],
       [ 0.43535449,  0.69695436,  0.25976013,  0.65293315,  0.12796236,
         0.89170976,  0.89538566,  0.7661741 ,  0.06041598,  0.75495737],
       [ 0.39672305,  0.48224634,  0.29196171,  0.01158065,  0.27270422,
         0.9055367 ,  0.77696274,  0.55111361,  0.36990923,  0.44839469],
       [ 0.49302039,  0.43910028,  0.69551093,  0.38485437,  0.59290733,
         0.60957991,  0.60690416,  0.7290093 ,  0.153923  ,  0.68158969],
       [ 0.18287042,  0.998713  ,  0.21240307,  0.76586074,  0.99363589,
         0.62133375,  0.47339622,  0.94654607,  0.1572087 ,  0.95343159],
       [ 0.57546028,  0.96684773,  0.91605759,  0.76285641,  0.39246144,
         0.5048398 ,  0.20537326,  0.03821489,  0.93846779,  0.67465357],
       [ 0.50036711,  0.01044893,  0.34497477,  0.86604052,  0.01158555,
         0.61679012,  0.18245735,  0.93472696,  0.95285364,  0.25008413],
       [ 0.02460187,  0.71865045,  0.88454367,  0.89606069,  0.007162  ,
         0.48205852,  0.8488491 ,  0.30527469,  0.09745148,  0.41324897],
       [ 0.85682063,  0.12847062,  0.20754213,  0.72276057,  0.55677094,
         0.4177689 ,  0.21974381,  0.27618731,  0.86658251,  0.13244381],
       [ 0.08830751,  0.86493876,  0.97546856,  0.90726232,  0.96354161,
         0.79810109,  0.41307841,  0.65814493,  0.93662478,  0.81531833]])

In [12]:

Zmin, Zmax = nd4.min(), nd4.max()

Zmin, Zmax

Out[12]:

(0.007161996597249809, 0.99871299576647787)

5、创建一个10*10的ndarray对象，且矩阵边界全为1，里面全为0

In [13]:

nd5 = np.ones((10,10))

nd5[1:-1,1:-1] = 0

nd5

Out[13]:

array([[ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.],
       [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.],
       [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.],
       [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.],
       [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.],
       [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.],
       [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.],
       [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.]])

6、创建一个每一行都是从0到4的5*5矩阵

In [14]:

nd6=np.arange(0,25,1)

nd6.resize((5,5))

nd61=np.arange(0,5,1)

nd6[0:5]=nd61

nd6

Out[14]:

array([[0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4]])

7、创建一个范围在(0,1)之间的长度为12的等差数列

In [15]:

nd7=np.linspace(0,1,12)

nd7

​

Out[15]:

array([ 0.        ,  0.09090909,  0.18181818,  0.27272727,  0.36363636,
        0.45454545,  0.54545455,  0.63636364,  0.72727273,  0.81818182,
        0.90909091,  1.        ])

8、创建一个长度为10的随机数组并排序

In [16]:

nd8=np.random.random(10)

nd8.sort()

nd8

Out[16]:

array([ 0.13239674,  0.24199985,  0.28860574,  0.31665663,  0.33797971,
        0.49389128,  0.54173172,  0.66709575,  0.87428616,  0.93431918])

9、创建一个长度为10的随机数组并将最大值替换为0

In [17]:

nd9=np.random.random(10)

nd9[nd9.argmax()]=0

nd9

Out[17]:

array([ 0.37927771,  0.74980137,  0.45306485,  0.        ,  0.38631354,
        0.03016797,  0.68861177,  0.78478335,  0.12929193,  0.38233788])

10、如何根据第3列来对一个5*5矩阵排序？

In [18]:

nd10=np.random.randint(0,20,size=(5,5))

nd10

Out[18]:

array([[ 4, 17,  7, 16,  7],
       [ 4, 11, 14, 19,  1],
       [10,  6,  1, 17,  0],
       [ 0, 10, 17, 13, 15],
       [ 1, 11,  3,  6, 16]])

In [19]:

sort_ind = np.argsort(nd10[:,3]) # 排序并且返回排序以后的下标序列

sort_ind

Out[19]:

array([4, 3, 0, 2, 1], dtype=int64)

In [20]:

nd10[sort_ind]

Out[20]:

array([[ 1, 11,  3,  6, 16],
       [ 0, 10, 17, 13, 15],
       [ 4, 17,  7, 16,  7],
       [10,  6,  1, 17,  0],
       [ 4, 11, 14, 19,  1]])

11、给定一个4维矩阵，如何得到最后两维的和？

In [21]:

nd11=np.random.randint(0,10,size=(2,3,2,2))

nd11

Out[21]:

array([[[[3, 3],
         [1, 5]],

        [[9, 9],
         [4, 3]],

        [[6, 4],
         [9, 0]]],


       [[[1, 8],
         [8, 7]],

        [[9, 0],
         [8, 2]],

        [[0, 1],
         [0, 1]]]])

In [22]:

nd11.sum(axis=-1)

nd11.sum(axis=-2)

nd11.sum(axis=(-1,-2))

Out[22]:

array([[12, 25, 19],
       [24, 19,  2]])

12、给定数组[1, 2, 3, 4, 5]，如何得到在这个数组的每个元素之间插入3个0后的新数组？

In [23]:

nd12=[1,2,3,4,5]

nd12

Out[23]:

[1, 2, 3, 4, 5]

In [24]:

nd12_v=np.vstack(nd12)

nd12_v

Out[24]:

array([[1],
       [2],
       [3],
       [4],
       [5]])

In [25]:

nd12_z=np.zeros((5,3),dtype="int32")

nd12_z

Out[25]:

array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])

In [26]:

np.concatenate([nd12_v,nd12_z],axis=1)

Out[26]:

array([[1, 0, 0, 0],
       [2, 0, 0, 0],
       [3, 0, 0, 0],
       [4, 0, 0, 0],
       [5, 0, 0, 0]])

13、给定一个二维矩阵，如何交换其中两行的元素？

In [27]:

nd13=np.random.randint(0,20,size=(3,4))

nd13

Out[27]:

array([[ 1, 12, 16, 13],
       [ 8, 13, 10,  4],
       [ 7,  7,  2,  5]])

In [28]:

nd13[[0,2,1]]

Out[28]:

array([[ 1, 12, 16, 13],
       [ 7,  7,  2,  5],
       [ 8, 13, 10,  4]])

14、创建一个100000长度的随机数组，使用两种方法对其求三次方，并比较所用时间

In [29]:

nd14=np.random.randint(0,100000,5)

nd14

Out[29]:

array([46129, 89120, 29541, 79550, 66737])

In [30]:

%timeit np.power(nd14, 3)

1.66 µs ± 131 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [31]:

nd14_2=np.dot(nd14,nd14)

%timeit np.dot(nd14_2,nd14)

2.51 µs ± 253 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

15、创建一个53随机矩阵和一个32随机矩阵，求矩阵积

In [32]:

nd15_1=np.random.randint(0,10,size=(5,3))

nd15_1

Out[32]:

array([[6, 7, 4],
       [0, 3, 8],
       [0, 0, 3],
       [0, 3, 2],
       [4, 1, 2]])

In [33]:

nd15_2=np.random.randint(0,10,size=(3,2))

nd15_2

Out[33]:

array([[1, 5],
       [1, 9],
       [6, 2]])

In [34]:

np.dot(nd15_1,nd15_2)

Out[34]:

array([[ 37, 101],
       [ 51,  43],
       [ 18,   6],
       [ 15,  31],
       [ 17,  33]])

16、矩阵的每一行的元素都减去该行的平均值

In [35]:

nd16=np.random.randint(0,10,size=(3,2))

nd16

Out[35]:

array([[2, 7],
       [6, 9],
       [2, 9]])

In [36]:

nd16_1=np.mean(nd16,axis=1)

nd16_2=np.vstack(nd16_1)

nd16_2

Out[36]:

array([[ 4.5],
       [ 7.5],
       [ 5.5]])

In [37]:

nd16-nd16_2

Out[37]:

array([[-2.5,  2.5],
       [-1.5,  1.5],
       [-3.5,  3.5]])

17、打印出以下函数（要求使用np.zeros创建8*8的矩阵）： [[0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0] [0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0] [0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0] [0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0]]

In [38]:

nd17=np.zeros((8,8),dtype="int32")

nd17

Out[38]:

array([[0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0]])

In [39]:

nd17[1::2,::2] = 1

nd17[::2,1::2] = 1

nd17

Out[39]:

array([[0, 1, 0, 1, 0, 1, 0, 1],
       [1, 0, 1, 0, 1, 0, 1, 0],
       [0, 1, 0, 1, 0, 1, 0, 1],
       [1, 0, 1, 0, 1, 0, 1, 0],
       [0, 1, 0, 1, 0, 1, 0, 1],
       [1, 0, 1, 0, 1, 0, 1, 0],
       [0, 1, 0, 1, 0, 1, 0, 1],
       [1, 0, 1, 0, 1, 0, 1, 0]])

18、正则化一个5*5随机矩阵 正则的概念：假设a是矩阵中的一个元素，max/min分别是矩阵元素的最大最小值，则正则化后a = (a - min)/(max - min)

In [40]:

nd18 = np.random.random((5,5))

max, min =nd18.max(),nd18.min()

nd18 = (nd18 - min)/(max - min)

nd18

Out[40]:

array([[ 0.25144383,  0.82645318,  0.        ,  0.18497809,  0.66760464],
       [ 0.98185414,  0.09698211,  0.40000897,  0.32858921,  1.        ],
       [ 0.20143467,  0.56118396,  0.53422648,  0.7448601 ,  0.79003777],
       [ 0.63127953,  0.24049893,  0.84784467,  0.01238311,  0.80379845],
       [ 0.46492319,  0.0671232 ,  0.71125054,  0.04335297,  0.05462583]])

19、将一个一维数组转化为二进制表示矩阵。例如 [1,2,3] 转化为 [[0,0,1], [0,1,0], [0,1,1]]

In [41]:

1 and 0

Out[41]:

0

In [42]:

1 or 0

Out[42]:

1

In [43]:

1 & 2

Out[43]:

0

In [44]:

# 60 = 1*2^5 + 1*2^4 + 1*2^3 +0*2^2+0*2^1+ 1*2^0

# 111001 & 2^3

​

#2 = 010

# 3 = 011

# 011

# 010

1 & 2**0

1 & 2**1

1 & 2**2

3 & 2**0

3 & 2**1

3 & 2**2

Out[44]:

0

In [45]:

I = np.array([1,2,3])

I

Out[45]:

array([1, 2, 3])

In [46]:

A = I.reshape((-1,1))

A

Out[46]:

array([[1],
       [2],
       [3]])

In [47]:

B = 2**np.arange(3)

B

Out[47]:

array([1, 2, 4], dtype=int32)

In [48]:

M = A & B

M

Out[48]:

array([[1, 0, 0],
       [0, 2, 0],
       [1, 2, 0]], dtype=int32)

In [49]:

M != 0

Out[49]:

array([[ True, False, False],
       [False,  True, False],
       [ True,  True, False]], dtype=bool)

In [50]:

M[M!=0] = 1

M

Out[50]:

array([[1, 0, 0],
       [0, 1, 0],
       [1, 1, 0]], dtype=int32)

In [51]:

M[:,::-1]

Out[51]:

array([[0, 0, 1],
       [0, 1, 0],
       [0, 1, 1]], dtype=int32)

20、实现冒泡排序法

In [52]:

nd20=[1,3,4,2,78,5,0,8]

for i in range(len(nd20) - 1):  

    for j in range(len(nd20)- 1 - i):  

        if nd20[j] > nd20[j+1]:  

            nd20[j],nd20[j+1] = nd20[j+1],nd20[j]

nd20

Out[52]:

[0, 1, 2, 3, 4, 5, 8, 78]