【总结笔记】numpy练习题（一）

---

本文是对numpy100道练习题的阶段总结(前50道大概)，主要列举其中个人觉得重要常用的部分

如有错误，欢迎指出

---

练习题

• 打印numpy版本和配置

• 创建数组

  • 创建空数组 size = 10
  • 创建一个大小为10但第5个值为1的零向量
  • 创建一个值从10到49的向量
  • 创建一个值从0到8的3x3矩阵
  • 创建一个3×3的单位矩阵(identity matrix)
  • 创建一个带有随机值的10x10数组，并查找最小值和最大值
  • 创建一个大小为30的随机向量并找出其平均值
  • 创建一个2d数组，边界为1，内部为0
  • 创建一个5x5的矩阵，在对角线下面的值为1,2,3,4
  • 创建一个8x8的矩阵，用棋盘格图案填充它
  • 使用tile函数创建一个8x8的棋盘矩阵
  • 创建一个5x5矩阵，其行值范围为0到4
  • 考虑一个生成10个整数的生成器函数，并使用它构建一个数组
  • 创建一个大小为10的向量，其值范围为0到1，两者都不包括在内
  • 创建一个大小为10的随机向量并对其排序
  • 创建大小为10的随机向量，并将最大值替换为0

• 求数组所占的内存大小

• 从命令行获取numpy add函数的文档

• 将一个向量倒置

• 从[1,2,0,0,4,0]中寻找非零元素的索引

• 如何添加一个边界(填充0)周围现有的数组?

• 下面这个表达式的结果是什么?

0 * np.nan
np.nan == np.nan
np.inf > np.nan
np.nan - np.nan
np.nan in set([np.nan])
0.3 == 3 * 0.1

• 归一化一个5x5的随机矩阵
• 创建一个自定义dtype，将颜色描述为四个无符号字节(RGBA)
• 【矩阵相乘】用一个5x3矩阵乘以一个3x2矩阵
• 给定一个1D数组，对3到8之间的所有元素进行取反
• 【出乎意料的结果】下面语句的输出是什么?

print(sum(range(5),-1))
from numpy import *
print(sum(range(5),-1))

• 如何从零四舍五入一个浮点数组？
• 如何找到两个数组之间的公共值?
• 下面的表达正确吗?

np.sqrt(-1) == np.emath.sqrt(-1)

• 时间操作
  • 如何得到昨天、今天和明天的日期?
  • 如何获取2016年7月对应的所有日期?
• 如何计算((A+B)*(-A/2))到位(没有复制)?
• 使用5种不同的方法提取随机数组的整数部分
• 小数组求和，且要求要比np.sum更快
• 考虑两个随机数组A和B，检查它们是否相等
• 使数组不可变(只读)
• 考虑一个表示笛卡尔坐标的随机10x2矩阵，将其转换为极坐标
• 创建一个结构化数组，x和y坐标覆盖[0,1]x[0,1]区域
• 给定两个数组X和Y，构造柯西矩阵C (Cij =1/(xi - yj))
• 打印每个numpy标量类型的最小和最大可表示值
• 如何打印数组的所有值
• 如何找到向量中(与给定标量)最接近的值
• 创建一个表示位置(x,y)和颜色(r,g,b)的结构化数组
• 考虑一个形状为(10,2)表示坐标的随机向量，逐点计算距离
• 如何转换一个浮点(32位)数组到整数(32位)

---

答案

• 打印numpy版本和配置

import numpy as np
np.__version__
np.show_config()

• 创建数组

# 创建空数组
np.zeros(10)

# 创建一个大小为10但第5个值为1的零向量
Z = np.zeros(10)
Z[5] = 1

# 创建一个值从10到49的向量
Z = np.arange(10, 50)

# 创建一个值从0到8的3x3矩阵
Z = np.arange(9).reshape((3, 3))

# 创建一个3×3的单位矩阵(identity matrix)
Z = np.eye(3)

# 创建一个带有随机值的10x10数组，并查找最小值和最大值
arr = np.random.random((10, 10))
print(np.max(arr))
print(np.min(arr))

# 创建一个大小为30的随机向量并找出其平均值(两种都可)
Z = np.random.random(30)
Z_mean = np.mean(Z)
m = Z.mean()
print(Z_mean)
print(m)

# 创建一个2d数组，边界为1，内部为0(相较创建0数组，1数组更方便)
np.ones((10, 10))
Z[1:-1, 1:-1] = 0

# 创建一个5x5的矩阵，在对角线下面的值为1,2,3,4
# np.diag(v, k) 
# v : array_like
# 如果v是二维数组，返回k位置的对角线。
# 如果v是一维数组，返回一个v作为k位置对角线的二维数组
# k : int, optional
# 默认为0，可选参数。
# 对角线的位置，大于零位于对角线上面，小于零则在下面。
Z = np.diag(1+np.arange(4), k=-1)

# 创建一个8x8的矩阵，用棋盘格图案填充它 (比较考验对索引的理解)
Z = np.zeros((8, 8))
Z[1::2, ::2] = 1
Z[::2, 1::2] = 1

# 使用tile函数创建一个8x8的棋盘矩阵
# tile function 平铺函数 功能好像是将第一个矩阵以平铺的形式 铺一定的次数 
Z = np.tile([1, 0], (4, 4))

# 创建一个5x5矩阵，其行值范围为0到4
Z = np.zeros((5, 5))
Z += np.arange(5)
print(Z)

# 考虑一个生成10个整数的生成器函数，并使用它构建一个数组
def generates():
    for x in range(10):
        yield x
Z = np.fromiter(generates(), dtype=float, count=-1)
print(Z)

# 创建一个大小为10的向量，其值范围为0到1，两者都不包括在内
# linspace 线性等分向量  分成十一份 第三个参数确是11
Z = np.linspace(0, 1, 11, endpoint=False)[1:]
print(Z)

# 创建一个大小为10的随机向量并对其排序
Z = np.random.random(10)
Z.sort()

# 创建大小为10的随机向量，并将最大值替换为0
Z = np.random.random(10)
print(Z)
Z[np.argmax(Z)] = 0
print(Z)

• 求数组所占的内存大小

z = np.zeros((10, 10)) # size of any array
print("%d bytes"%(z.size * z.itemsize))

• 从命令行获取numpy add函数的文档

%run `python -c "import numpy; numpy.info(numpy.add)"`

• 将一个向量倒置

Z = Z[::-1]

• 从[1,2,0,0,4,0]中寻找非零元素的索引

nz = np.nonzero([1,2,0,0,4,0])
print(nz)

• 如何添加一个边界(填充0)周围现有的数组?

# 第一个参数是待填充数组
# 第二个参数是填充的形状
# 第三个参数(mode)是填充的方法
# 关于填充方法 (这部分没太细究，直接抄过来的)
# constant连续一样的值填充，有关于其填充值的参数。 constant_values=（x, y）时前面用x填充，后面用y填充。缺参数视为0
# edge用边缘值填充
# linear_ramp边缘递减的填充方式
# maximum, mean, median, minimum分别用最大值、均值、中位数和最小值填充
# reflect, symmetric都是对称填充。前一个是关于边缘对称，后一个是关于边缘外的空气对称
# wrap用原数组后面的值填充前面，前面的值填充后面
# 也可以有其他自定义的填充方法
Z_pad = np.pad(Z, pad_width=1, mode='constant', constant_values=0)

• 表达式的结果

0 * np.nan （nan）
np.nan == np.nan （False）
np.inf > np.nan（False）
np.nan - np.nan（nan）
np.nan in set([np.nan])（True）
0.3 == 3 * 0.1（False）

• 归一化一个5x5的随机矩阵

# Normalize 归一化  归一化就是把需要处理的数据经过处理后限制在自己需要的一定范围内；归一化是为了后面数据处理的方便，
# 其次是保证程序运行时收敛加快
Z = np.random.random((5, 5))
print(Z)
Z = ((Z - np.mean(Z)) / np.std(Z))

• 创建一个自定义dtype，将颜色描述为四个无符号字节(RGBA)

color = np.dtype([("r", np.ubyte, 1),
                  ("g", np.ubyte, 1),
                  ("b", np.ubyte, 1), 
                  ("a", np.ubyte, 1)])

• 用一个5x3矩阵乘以一个3x2矩阵

A = np.random.random((5, 3))
B = np.random.random((3, 2))
Z = np.dot(A, B) 
print(Z)

• 给定一个1D数组，对3到8之间的所有元素进行取反

Z = np.arange(11)
# 此处只能用 & 而不用 &&
Z[(Z > 3) & (Z <= 8)] *= -1
print(Z)

• 下面语句的输出是什么?

# 结果 9  10
#https://stoneboy100200.github.io/2018/08/09/numpy-sum/
# 第一个使用的是原生的sum()函数，第二个是np中的sum(),二者参数定义不同；第一个加完后还要再-1，第二个-1代表的是最后一个维度
print(sum(range(5),-1))
from numpy import *
print(sum(range(5),-1))

• 如何从零四舍五入一个浮点数组

# numpy.random.uniform(low,high,size) 从一个均匀分布[low,high)中随机采样，
Z = np.random.uniform(-10, +10, 10)
# np.copysign(x1, x2) 将x1的符号按元素顺序改为x2的符号
print(np.copysign(np.ceil(np.abs(Z)), Z))

• 如何找到两个数组之间的公共值?

# numpy.random.randint(low, high=None, size=None, dtype='l') size默认是None的，仅仅返回满足要求的单一随机数
Z1 = np.random.randint(0, 10, 10)
print(Z1)
Z2 = np.random.randint(0, 10, 10)
print(Z2)
# numpy.intersect1d(arr1, arr2, assume_unique = False, return_indices = False)
# 查找两个数组的交集，并返回两个输入数组中都有序的，唯一的值
print(np.intersect1d(Z1, Z2))

• 下面的表达正确吗?

np.sqrt(-1) == np.emath.sqrt(-1)

# 前者只能接受一个大于0的数，也就是前面的运算只能得到一个实数；而后者可以接受一个负数，运算结果也可以是一个虚数。
print(np.sqrt(-1) == np.emath.sqrt(-1))

• 时间操作

# 如何得到昨天、今天和明天的日期?
yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')
today = np.datetime64('today', 'D')
print(yesterday)
print(today)

# 如何获取2016年7月对应的所有日期?
# 得到某一年具体月份的全部日期
july = np.arange('2016-07', '2016-08', dtype='datetime64[D]')

• 如何计算((A+B)*(-A/2))到位(没有复制)?

# in place 原地计算？
A = np.ones(3)*1
B = np.ones(3)*2
# C = np.ones(3)*3
np.add(A, B, out=B)
np.divide(A, 2, out=A)
np.negative(A, out=A)
np.multiply(A, B, out=A)
print(A)

• 使用5种不同的方法提取随机数组的整数部分

# 提取random数组中的整数部分
Z = np.random.uniform(1, 10, 10)
print(Z)
print(Z - Z%1)
print(Z//1)
print(np.floor(Z))
print(np.ceil(Z)-1)
print(Z.astype(int))
# trunc 将数字截尾取整
print(np.trunc(Z))

• 小数组求和，且要求要比np.sum更快

# 比np.sum()加得更快  两者的性能似乎有很大的不同:对于相对较小的数组大小，add.reduce的速度大约快两倍。 对于更大的数组大小，差异似乎消失了
Z = np.arange(10)
# reduce
# 用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，
# 得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
np.add.reduce(Z)

• 考虑两个随机数组A和B，检查它们是否相等

A = np.random.randint(0, 2, 5)
B = np.random.randint(0, 2, 5)
# Assuming identical shape of the arrays and a tolerance for the comparison of values
# 用于匹配两个数组，输出为布尔值，默认在1e-05的误差范围内。numpy.allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)
print(A)
print(B)
equal = np.allclose(A, B)
print(equal)
# 总之先记住该函数的比较有一定的容忍度
array1 = np.array([0.12,0.17,0.24,0.29])
array3 = np.array([0.12,0.18,0.24,0.29])
array2 = np.array([0.13,0.19,0.26,0.31])
print(np.allclose(array3,array2,0.1))
# Checking both the shape and the element values, no tolerance (values have to be exactly equal)
equal = np.array_equal(A,B)
print(equal)

• 使数组不可变(只读)

# immutable 不可变的
Z = np.arange(10)
Z.flags.writeable = False
Z[0] = 1
print(Z)

• 考虑一个表示笛卡尔坐标的随机10x2矩阵，将其转换为极坐标

Z = np.random.random((10, 2))
Y, X = Z[:, 0], Z[:, 1]
R = np.sqrt(Y**2 + X**2)
T = np.arctan2(Y, X)
print(R)
print(T)

• 创建一个结构化数组，x和y坐标覆盖[0,1]x[0,1]区域

Z = np.zeros((5, 5), [('x', float), ('y', float)])
print(Z)
Z['x'], Z['y'] = np.meshgrid(np.linspace(0,1,5), 
                             np.linspace(0,1,5))
print(Z)

• 给定两个数组X和Y，构造柯西矩阵C (Cij =1/(xi - yj))

# Cauchy matrix 柯西矩阵
X = np.arange(8)
Y = X + 0.5
C = 1.0 / np.subtract.outer(X, Y)
print(np.linalg.det(C))  # 利用np.linalg.det求行列式

• 打印每个numpy标量类型的最小和最大可表示值

for i in [np.int8, np.int32, np.int64, np.int]:
    # numpy.iinfo()函数显示整数类型的机器限制
    print(np.iinfo(i).min)
    print(np.iinfo(i).max)
for i in [np.float16, np.float32, np.float64, np.float]:
    print(np.finfo(i).min)
    print(np.finfo(i).max)
print(2 ** 16)

• 如何打印数组的所有值

np.set_printoptions(threshold=np.nan)
print(Z)

• 如何找到向量中(与给定标量)最接近的值

Z = np.arange(100)
v = np.random.uniform(0, 100)
# np.abs(Z-v) 形成了新的数组
index = (np.abs(Z-v)).argmin()
print(Z[index])

• 创建一个表示位置(x,y)和颜色(r,g,b)的结构化数组

Z = np.zeros(10, [('posi', [('x', float, 1), ('y', float, 1)]),
                 ('color', 
                  [('r', float, 1), 
                   ('g', float, 1), 
                   ('b', float, 1)])])

• 考虑一个形状为(10,2)表示坐标的随机向量，逐点计算距离

Z = np.random.random((10, 2))
X, Y = np.atleast_2d(Z[:, 0], Z[:, 1])
d = np.sqrt((X-X.T)**2+(Y-Y.T)**2)
print(d.shape)

# Much faster with scipy
import scipy
# Thanks Gavin Heverly-Coulson (#issue 1)
import scipy.spatial

Z = np.random.random((10,2))
D = scipy.spatial.distance.cdist(Z,Z)
print(D)
print(D.shape)

• 如何转换一个浮点(32位)数组到整数(32位)

Z = np.arange(10, dtype=np.float32)
Z = Z.astype(np.int32, copy=False)
print(Z)