numpy练习

import numpy as np

# 1、创建一个大小为10的空向量

# 2、创建一个大小为10的空向量，但是第五个值为1

# 3、创建一个10-49的ndarray数组

# 4、创建一个3x3的矩阵，其值在0-8之间

# 5、创建包含随机值的10x10数组，并且找到最小值和最大值

# 6、创建大小为30的随机向量，找到平均值

# 7、创建一个大小为100的随机数组，并对其进行排序

# 8、将一个float32的数组转换为int32位的数组

# 9、如何交换两行数组

# 10、创建一个边界值为1而内部都为0的数组

1、创建一个大小为10的空向量

arr = np.zeros(10)
arr
> array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

2、创建一个大小为10的空向量，但是第五个值为1

arr = np.zeros(10)
arr[4] = 1
arr
> array([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])

3、创建一个10-49的ndarray数组

arr = np.arange(10,50)
arr
> array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
       27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
       44, 45, 46, 47, 48, 49])

4、创建一个3×3的矩阵，其值在0-8之间

arr = np.arange(9).reshape(3,3)
arr
> array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

5、创建包含随机值的10×10数组，并且找到最小值和最大值

arr = np.random.random((10,10))
zmin,zmax = arr.min(),arr.max()
print(zmin,zmax)
> 0.011169609398906433 0.9911674728361876

6、创建大小为30的随机向量，找到平均值

arr = [np.random.randint(30) for _ in range(30)]
np.mean(arr)
> 13.833333333333334

7、创建一个大小为100的随机数组，并对其进行排序

arr = [np.random.randint(100) for _ in range(100)]
arr.sort()
arr
> [0,
 1,
 4,
 5,
 5,
...
 93,
 97,
 97,
 99,
 99]

8、将一个float32的数组转换为int32位的数组

Z = np.arange(10,dtype=np.float32)
Z = Z.astype(np.int32)
Z.dtype
> dtype('int32')

9、如何交换两行数组

arr = np.arange(25).reshape(5, 5)
arr[[ 0, 1 ]] = arr[[ 1, 0 ]]
arr
> array([[ 5,  6,  7,  8,  9],
       [ 0,  1,  2,  3,  4],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])

10、创建一个边界值为1而内部都为0的数组

Z = np.ones((10, 10))
Z[1:9, 1:9] = 0
Z
> 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.]])

​