关键词：
一、numpy的简介
numpy是Python的一种开源的数值计算扩展库。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。
NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。
Numpy中包含了大量的矩阵运算，所以读者最好具有一点儿线性代数的基础。
二、numpy基本使用
1. 导入numpy库并使用numpy的array方法配合Python中的list生成矩阵
import numpy as np vetor = np.array([1,2,3,4]) # 一维 matrix = np.array([ [1,1,1], [2,2,2], [3,3,3] ]) # 二维 print(vetor) print(matrix)
输出：
[1 2 3 4] [[1 1 1] [2 2 2] [3 3 3]]
2. 获取矩阵的组成
print(vetor.shape) print(matrix.shape)
输出：
(4,)
(3, 3)
3. 数据类型
numbers = np.array([1,3,5,7]) # 全为int型 print(numbers) numbers.dtype
输出：
[1 3 5 7] dtype(‘int64‘)
numbers = np.array([1,3,5,7.0]) # 有一个为float型，全为float型 print(numbers) numbers.dtype
[1. 3. 5. 7.] dtype(‘float64‘)
numbers = np.array([1,3,5,‘7‘]) # 有一个为字符串，全为字符串 print(numbers) numbers.dtype
[‘1‘ ‘3‘ ‘5‘ ‘7‘] dtype(‘<U21‘)
4. 操作矩阵的某个值，某些值
vetor = np.array([1,2,3,4]) matrix = np.array([[1,2,3],[4,5,6],[7,8,9]]) print(vetor[2]) # 打印vetor的第2个元素 print(vetor[:3]) # 打印vetor的第0到第二个（不包括第三个）元素 print(matrix[2,2]) # 打印matrix第2行，第2列的元素 print(matrix[:, 1]) # 打印每一行的第1列元素
输出：
3 [1 2 3] 9 [2 5 8]
5. 迭代判断矩阵中的所有值是否等于某个值
import numpy as np vector = np.array([1,3,5,7]) vector == 5
输出：
array([False, False, True, False])
matrix = np.array([ [1, 4, 7], [2, 5, 8], [3, 6, 9] ]) matrix == 5
array([[False, False, False],
[False, True, False],
[False, False, False]])
vector = np.array([1,3,4,5,7]) equal_three_and_five = (vector == 3) & (vector == 5) # 迭代判断vector中的所有值是否即等于3又等于5 print(equal_three_and_five)
[False False False False False]
vector = np.array([1,3,4,5,7]) equal_three_or_five = (vector == 3) | (vector == 5) # 迭代判断vector中的所有值是否即等于3或者等于5 print(equal_three_or_five)
[False True False True False]
matrix = np.array([ [1, 4, 7], [2, 5, 8], [3, 6, 9] ]) equal_ten = (matrix == 5) # 比较的结果可视为一个索引 print(equal_ten) print(matrix[equal_ten])
[[False False False]
[False True False]
[False False False]]
[5]
matrix = np.array([ [1, 4, 7], [2, 5, 8], [3, 6, 9] ]) equal_ten = (matrix[:, 1] == 5) # 迭代判断matrix的第1列的值是否等于5 print(equal_ten) print(matrix[equal_ten, :])
[False True False]
[[2 5 8]]
vector = np.array([1,3,4,5,7]) equal_three_or_five = (vector == 3) | (vector == 5) # 迭代判断vector中的所有值是否即等于3或者等于5 vector[equal_three_or_five] = 10 # 将等于3或者等于5的值替换成10 print(vector)
[ 1 10 4 10 7]
6.类型转换
vector = np.array([‘1‘, ‘3‘, ‘5‘, ‘7‘]) print(vector.dtype) print(vector) vector = vector.astype(int) #使用astype方法做类型转换 print(vector.dtype) print(vector)
输出：
<U1 [‘1‘ ‘3‘ ‘5‘ ‘7‘] int64 [1 3 5 7]
7.常规计算
vector = np.array([1,3,4,5,7]) print(vector.min()) #求最大值 print(vector.max()) #求最小组
输出：
1 7
# 示例2
matrix = np.array([ [1, 4, 7], [2, 5, 8], [3, 6, 9] ]) print(matrix.min(axis=1)) # 按行求最小值，axis=1表示按行 print(matrix.max(axis=0)) # 按列求最大值，axis=0表示按列 print(matrix.max()) # 所有值求最大值
# 输出2 [1 2 3] [3 6 9] 9
# 示例3 matrix = np.array([ [1, 4, 7], [2, 5, 8], [3, 6, 9] ]) print(matrix.sum(axis=1)) # 按行求和 print(matrix.sum(axis=0)) # 按列求和 print(matrix.sum()) # 所有值求和
# 输出3 [12 15 18] [ 6 15 24] 45
8.生成初始矩阵
# 示例1 print(np.arange(15)) # 取0到14组成一个一维矩阵 a = np.arange(15).reshape(3,5) # 取0到14组成一个3行5列的2维矩阵 print(a)
# 输出1 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14] [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]]
# 示例2 a.ndim # 获取a的维度 a.dtype.name #获取a中数据的类型 a.size # a中数据的数量
# 示例3 b = np.zeros((3, 4)) # 一个3行4列的矩阵， 由0构成 print(b)
# 输出3 [[0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.]]
# 示例4 c = np.ones((2,3,4), dtype=np.int32) # 3维矩阵，2组3行4列的2维矩阵，由1构成 print(c)
# 输出4 [[[1 1 1 1] [1 1 1 1] [1 1 1 1]] [[1 1 1 1] [1 1 1 1] [1 1 1 1]]]
# 示例5 d = np.arange(10, 30, 5) #初值为10，增量为5，最大不超过30，构成一维矩阵，numpy中arange的用法几乎和Python中的range一样 print(d)
# 输出5 [10 15 20 25]
# 示例6 e = np.random.random((2, 3)) #由0到1之间的随机数构成一个2行3列的矩阵，np.random中的方法几乎和Python的random模块中的方法相同 print(e)
# 输出6 [[0.26358359 0.86922218 0.12168824] [0.58244693 0.30264221 0.795065 ]]
# 示例7 from numpy import pi f = np.linspace(0, 2*pi, 100) #由0到2pi中间的100个数构成一个一维矩阵，这些书之间的增量相同 print(f)
# 输出7 [0. 0.06346652 0.12693304 0.19039955 0.25386607 0.31733259 0.38079911 0.44426563 0.50773215 0.57119866 0.63466518 0.6981317 0.76159822 0.82506474 0.88853126 0.95199777 1.01546429 1.07893081 1.14239733 1.20586385 1.26933037 1.33279688 1.3962634 1.45972992 1.52319644 1.58666296 1.65012947 1.71359599 1.77706251 1.84052903 1.90399555 1.96746207 2.03092858 2.0943951 2.15786162 2.22132814 2.28479466 2.34826118 2.41172769 2.47519421 2.53866073 2.60212725 2.66559377 2.72906028 2.7925268 2.85599332 2.91945984 2.98292636 3.04639288 3.10985939 3.17332591 3.23679243 3.30025895 3.36372547 3.42719199 3.4906585 3.55412502 3.61759154 3.68105806 3.74452458 3.8079911 3.87145761 3.93492413 3.99839065 4.06185717 4.12532369 4.1887902 4.25225672 4.31572324 4.37918976 4.44265628 4.5061228 4.56958931 4.63305583 4.69652235 4.75998887 4.82345539 4.88692191 4.95038842 5.01385494 5.07732146 5.14078798 5.2042545 5.26772102 5.33118753 5.39465405 5.45812057 5.52158709 5.58505361 5.64852012 5.71198664 5.77545316 5.83891968 5.9023862 5.96585272 6.02931923 6.09278575 6.15625227 6.21971879 6.28318531]
9.矩阵的基础运算
# 示例2 # 矩阵的加减运算 a = np.array([20, 30, 40, 50]) b = np.arange(4) print(a) print(b) c = a - b # 将a与b对应的位置相减 d = a + b # 将a与b对应的位置相加 print(‘----------->‘) print(c) print(d) c = c -2 print(‘----------->‘) print(c) print(b ** 2) # 对b中的每个元素平方 print(a < 40) # 迭代判断a中的元素是否小于40
#输出1 [20 30 40 50] [0 1 2 3] -----------> [20 29 38 47] [20 31 42 53] -----------> [18 27 36 45] [0 1 4 9] [ True True False False]
# 示例2 # 矩阵的乘法 A = np.array([ [1, 1], [0, 1] ]) B = np.array([ [2, 0], [3, 4] ]) print(A) print("=============") print(B) print("=============") print(A*B) # 矩阵对应位置的元素相乘 print("=============") print(A.dot(B)) # 矩阵乘积 print("=============") print(np.dot(A, B)) # 矩阵乘积
# 输出2 [[1 1] [0 1]] ============= [[2 0] [3 4]] ============= [[2 0] [0 4]] ============= [[5 4] [3 4]] ============= [[5 4] [3 4]]
10.矩阵的其他操作
# 示例1 import numpy as np B = np.arange(3) print(B) print(np.exp(B)) # 分别计算e的0，1，2（即B中的每个元素）次幂 print(np.sqrt(B)) # 对B求算数平方根 # 输出1： [0 1 2] [1. 2.71828183 7.3890561 ] [0. 1. 1.41421356]
# 示例2 a = np.random.random((3, 4)) print(a) b = np.floor(10 * a) #取整，截除小数点后面的部分 print(b) print("------------------------------>") c = b.ravel() # 二维转一维，即矩阵转向量，返回一个新的矩阵，自身结构不改变 print(c) c.shape = (6, 2) # 一维转二维，向量转为6×2的矩阵，对自己自身结构 print(c) print("------------------------------>") d = c.T print(c.T) # 对矩阵进行转置 # 输出2： [[0.07997894 0.66199346 0.66872968 0.09003685] [0.80189354 0.02278636 0.82955998 0.3037011 ] [0.31794432 0.67269324 0.12022113 0.12148777]] [[0. 6. 6. 0.] [8. 0. 8. 3.] [3. 6. 1. 1.]] ------------------------------> [0. 6. 6. 0. 8. 0. 8. 3. 3. 6. 1. 1.] [[0. 6.] [6. 0.] [8. 0.] [8. 3.] [3. 6.] [1. 1.]] ------------------------------> [[0. 6. 8. 8. 3. 1.] [6. 0. 0. 3. 6. 1.]]
# 示例3 import numpy as np a = np.floor(10 * np.random.random((2, 2))) b = np.floor(10 * np.random.random((2, 2))) print(a) print(b) print("------------------------------>") c = np.vstack((a, b)) # 将两个矩阵按行合并，两个矩阵的列必须相同 print(c) print("------------------------------>") d = np.hstack((a, b)) # 两个矩阵按列合并，两个矩阵的行必须相同 print(d) # 输出3： [[8. 7.] [0. 0.]] [[6. 9.] [0. 1.]] ------------------------------> [[8. 7.] [0. 0.] [6. 9.] [0. 1.]] ------------------------------> [[8. 7. 6. 9.] [0. 0. 0. 1.]]
# 示例4 import numpy as np a = np.floor(10 * np.random.random((2, 12))) print(a) print("------------------------------>") b,c,d = np.hsplit(a, 3) # 按列切平均分为3份 print(b) print(c) print(d) print("------------------------------>") e,f,g = np.vsplit(a.T, 3) # 按行切平均分为3份 print(e) print(f) print(g) print("------------------------------>") h, i, j, k = np.hsplit(a, (3, 6, 8)) # 在第3列前面，第6列前面，第8列后面进行分割，分割为4个矩阵，np.vsplit()用法相同 print(h) print(i) print(j) print(k) # 输出4： [[3. 1. 7. 4. 1. 1. 5. 8. 3. 9. 5. 6.] [2. 7. 6. 3. 7. 1. 6. 3. 5. 7. 9. 0.]] ------------------------------> [[3. 1. 7. 4.] [2. 7. 6. 3.]] [[1. 1. 5. 8.] [7. 1. 6. 3.]] [[3. 9. 5. 6.] [5. 7. 9. 0.]] ------------------------------> [[3. 2.] [1. 7.] [7. 6.] [4. 3.]] [[1. 7.] [1. 1.] [5. 6.] [8. 3.]] [[3. 5.] [9. 7.] [5. 9.] [6. 0.]] ------------------------------> [[3. 1. 7.] [2. 7. 6.]] [[4. 1. 1.] [3. 7. 1.]] [[5. 8.] [6. 3.]] [[3. 9. 5. 6.] [5. 7. 9. 0.]]
11.矩阵的复制
# 示例1 a = np.arange(12) b = a # 这种方式对b赋值，b和a是同一个对象，改变一个，另一个也改变，相当于别名 print(b) print(a) print(b is a) print("------------------------------>") a.shape = (3, 4) print(a) print(b) print(b.shape) print(id(a)) print(id(b)) 输出1： [ 0 1 2 3 4 5 6 7 8 9 10 11] [ 0 1 2 3 4 5 6 7 8 9 10 11] True ------------------------------> [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] (3, 4) 4426322848 4426322848
# 示例2 # 浅拷贝（不建议使用） a = np.arange(12) a.shape = (2, 6) c = a.view() # 浅拷贝，c和a是两个对象，但是是同一份数据 print(a) print(c) print(c is a) print("------------------------------>") a.shape = (3, 4) # 改变结构，两个不相互影响 print(a) print(c) print("------------------------------>") c[0,4] = 10000 # 改变数据，会影响另外一个 print(a) print(c) # 输出2： [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]] [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]] False ------------------------------> [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]] ------------------------------> [[ 0 1 2 3] [10000 5 6 7] [ 8 9 10 11]] [[ 0 1 2 3 10000 5] [ 6 7 8 9 10 11]]
# 示例3 # 深拷贝 a = np.arange(12) a.shape = (2, 6) d = a.copy() # 深拷贝，d和a是两个对象，两份数据 print(a) print(d) print(d is a) print("------------------------------>") a.shape = (3, 4) # 改变结构，两个不相互影响 print(a) print(d) print("------------------------------>") d[0,4] = 10000 # 改变数据，两个不相互影响 print(a) print(d) # 输出3： [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]] [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]] False ------------------------------> [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]] ------------------------------> [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[ 0 1 2 3 10000 5] [ 6 7 8 9 10 11]]
12.numpy的一些常用方法：
# 示例1 import numpy as np data = np.sin(np.arange(20)).reshape(5, 4) print(data) ind = data.argmax(axis = 0) # 按列求最大值，得到行的索引，比如第1列的最大值在第2行，则返回2，依次求出所有列最大值的索引组成一个向量 print(ind) print(range(data.shape[1])) data_max = data[ind, range(data.shape[1])] # 相当于由data[2,0],data[0,1],data[3,2],data[1,3]构成的一个矩阵 print(data_max) # 输出1： [[ 0. 0.84147098 0.90929743 0.14112001] [-0.7568025 -0.95892427 -0.2794155 0.6569866 ] [ 0.98935825 0.41211849 -0.54402111 -0.99999021] [-0.53657292 0.42016704 0.99060736 0.65028784] [-0.28790332 -0.96139749 -0.75098725 0.14987721]] [2 0 3 1] range(0, 4) [0.98935825 0.84147098 0.99060736 0.6569866 ]
# 示例2 a = np.arange(0, 10, 2) print(a) b = np.tile(a, (4, 3)) # 将a当成一个整体，将其复制为4行3列构成一个矩阵 print(b) print(‘----------------------------------->‘) c = np.arange(0, 11, 2) c.shape = (2, 3) # 对于二维同样如此 print(c) d = np.tile(c, (4, 3)) print(d) # 输出2： [0 2 4 6 8] [[0 2 4 6 8 0 2 4 6 8 0 2 4 6 8] [0 2 4 6 8 0 2 4 6 8 0 2 4 6 8] [0 2 4 6 8 0 2 4 6 8 0 2 4 6 8] [0 2 4 6 8 0 2 4 6 8 0 2 4 6 8]] -----------------------------------> [[ 0 2 4] [ 6 8 10]] [[ 0 2 4 0 2 4 0 2 4] [ 6 8 10 6 8 10 6 8 10] [ 0 2 4 0 2 4 0 2 4] [ 6 8 10 6 8 10 6 8 10] [ 0 2 4 0 2 4 0 2 4] [ 6 8 10 6 8 10 6 8 10] [ 0 2 4 0 2 4 0 2 4] [ 6 8 10 6 8 10 6 8 10]]
# 示例3 a = np.floor(10 * np.random.random((15))) c = a.copy() a.shape = (5, 3) print(a) print(‘----------------------------------->‘) b = np.sort(a, axis=0) # axis=0按列进行升序排序， axis=1按行升序排序， 默认按行排序 print(b) print(‘----------------------------------->‘) a.sort(axis=1) print(a) print(‘----------------------------------->‘) j = np.argsort(c) # 排序，取原来的索引，比如[5 3 6]执行，得到[1 0 2], print(c) print(j) print(c[j]) # 输出3： [[2. 5. 5.] [6. 4. 9.] [8. 3. 0.] [2. 3. 0.] [5. 5. 4.]] -----------------------------------> [[2. 3. 0.] [2. 3. 0.] [5. 4. 4.] [6. 5. 5.] [8. 5. 9.]] -----------------------------------> [[2. 5. 5.] [4. 6. 9.] [0. 3. 8.] [0. 2. 3.] [4. 5. 5.]] -----------------------------------> [2. 5. 5. 6. 4. 9. 8. 3. 0. 2. 3. 0. 5. 5. 4.] [ 8 11 0 9 7 10 4 14 1 2 12 13 3 6 5] [0. 0. 2. 2. 3. 3. 4. 4. 5. 5. 5. 5. 6. 8. 9.]
《机器学习实战》-机器学习基础(代码片段)
目录机器学习基础什么是机器学习机器学习应用场景海量数据机器学习的重要性机器学习的基本术语监督学习和非监督学习监督学习：supervisedlearning非监督学习：unsupervisedlearning机器学习工具介绍Python非PythonNumPy函数库基础测试Nu... 查看详情
学机器学习，不会数据分析怎么行？之numpy详解(代码片段)
最近学习强化学习和机器学习，意识到数据分析的重要性，就开始补Python的几个科学计算库，并总结到博客中。本篇博客中用到的代码在这里下载。什么是Numpy？ NumPy是Python数值计算最重要的基础包，支持高级大量的维度数... 查看详情
张量tensor[机器学习的数学基础](代码片段)
1、张量是什么 当前的机器学习模型基本都使用张量（Tensor）作为基本的数据结构，与数组和矩阵非常相似。在PyTorch中，我们使用张量来编码一个模型的输入和输出，以及模型的参数。 张量（Tensor&... 查看详情
机器学习入门(代码片段)
python关于向量 python中的List的特点:不限制其中每一个元素的类型,可以使用下标访问,但是比较慢. 也可以使用array. 需要importarrary这个包.importarrayarr=array.array('i',[iforiinrange(10)])arr输出:array('i',[0,1,2,3,4,5,6,7,8,9])... 查看详情
python机器学习入门——科学计算库（numpy）(代码片段)
目录Numpy优势Numpy效率ndarray介绍ndarray与Python原生list运算效率对比N维数组-ndarrayndarray的属性ndarray的形状,ndarray的类型基本操作生成数组的方法生成0和1的数组:生成数组的方法从现有数组生成生成固定范围的数组生成随机数组使用... 查看详情
机器学习算法_knn(福利)(代码片段)
这两天翻了一下机器学习实战这本书，算法是不错，只是代码不够友好，作者是个搞算法的，这点从代码上就能看出来。可是有些地方使用numpy搞数组，搞矩阵，总是感觉怪怪的，一个是需要使用三方包numpy，虽然这个包基本可... 查看详情
python基础库及机器学习笔记(代码片段)
1.介绍本节将主要介绍Python中的常用第三方库。这些库都是实现了各种计算功能的开源库，它们极大地丰富了Python的应用场景和计算能力，这里主要介绍NumPy、pandas和Matplotlib三个库的基础使用。其中NumPy是Python用来进行矩... 查看详情
机器学习入门之使用numpy和matplotlib绘制图形(代码片段)
机器学习当中能深入浅出的方法第一步就是先学会用numpy了。numpy是一个第三方的开源python库，他提供了许多科学的数值计算工具，尤其是大型矩阵计算，但使用配置非常简单，结合matplotlib能够非常方便的将计算结果展示成... 查看详情
数据分析基础(代码片段)
...？1、他有岗位要求。2、它是Python数据科学的基础3、它是机器学习课程的基础。数据分析的流程： 1、提出问题 2、准备数据 3、分析数据 4、获得结论 5、成果可视化开发环境介绍anaconda：一种机器学习和数据... 查看详情
机器学习基础环境部署|机器学习系列(代码片段)
...Spyder配置与使用安装PyTorch总结前言本文主要是分享一下机器学习初期，基本的环境搭建。也适用于其他python工程化项目环境搭建。都差不多。Anaconda安装anaconda官方链接：Anaconda|TheWorld'sMostPopularDataSciencePlatform点 查看详情
python机器学习库numpy教程(代码片段)
0Numpy简单介绍Numpy是Python的一个科学计算的库，提供了矩阵运算的功能，其一般与Scipy、matplotlib一起使用。其实，list已经提供了类似于矩阵的表示形式，不过numpy为我们提供了更多的函数。如果接触过matlab、scilab，那么numpy很好... 查看详情
深度学习基础-机器学习基本原理(代码片段)
前言深度学习是机器学习的一个特定分支。我们要想充分理解深度学习，必须对机器学习的基本原理有深刻的理解。大部分机器学习算法都有超参数（必须在学习算法外手动设定）。机器学习本质上属于应用统计学，其更加强调... 查看详情
机器学习---初识python的numpy模块(代码片段)
...，字面意思是Python数值计算扩展。Numpy是python中众多机器学习库的依赖，这些库通过Numpy实现基本的矩阵计算。 Numpy支持高阶、大量计算的矩阵、向量计算，与此同时还提供了较为丰富的函数。此外，Num... 查看详情
机器学习jupyternotebook,numpy和matplotlib的详细使用(上)
工欲善其事，必先利其器。在本章，我们将学习和机器学习相关的基础工具的使用：JupyterNotebook,numpy和matplotlib。大多数教程在讲解机器学习的时候，大量使用这些工具，却不对这些工具进行系统讲解。我特意添加了这个章节，... 查看详情
numpy的介绍与基本使用方法(代码片段)
...个单词--Numerical和Python。?它是Python生态系统中数据分析、机器学习和科学计算的主力军。它极大地简化了向量和矩阵的操作处理。Python数据科学相关的一些主要软件包（如scikit-learn、SciPy、pandas和tensorflow）都以NumPy作为其架构的... 查看详情
机器学习基础及案例
下面是部分机器学习的案例，合适入门的朋友学习，有numpy、pandas、matplotlib、scipy、skearn、TensorFlow等库的基本案例教程。 查看详情
机器学习手稿--numpy篇(代码片段)
什么是NumPy？NumPy是python语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对预算提供大量的数学函数库2005年开发者在Numeric中结合了另一个同性质的程序库Numarray的特色，并加入了其他扩展而开发了NumPy。NumPy为... 查看详情
深度学习基础之numpy，小白轻松入门numpy，送书了！！！(代码片段)
目录1、numpy的安装2、快速入门3.Numpy数组操作4、常用函数5、ndarray和list的区别6、总结送书活动第一期1、numpy的安装pipinstallnumpy2、快速入门2.1数据类型用过C语言的基本上都知道是哪几个类型，毕竟python是c实现的总结一下... 查看详情