<jupyter_start><jupyter_text>Table of Contents1&nbsp;&nbsp;Numpy1.1&nbsp;&nbsp;Numpy简介1.2&nbsp;&nbsp;ndarray2&nbsp;&nbsp;ndarray数组的创建和变换2.1&nbsp;&nbsp;从Python中的列表、元组等类型创建ndarray数组。2.2&nbsp;&nbsp;使用 NumPy中函数创建ndarray数组,如: arange, ones, zeros等2.3&nbsp;&nbsp;ndarray数组的变换2.3.1&nbsp;&nbsp;ndarray数组的维度变换2.3.2&nbsp;&nbsp;ndarray数组的类型变换3&nbsp;&nbsp;ndarray数组的操作3.1&nbsp;&nbsp;数组的索引和切片3.2&nbsp;&nbsp;ndarray数组的运算4&nbsp;&nbsp;NumPy的随机数函数4.1&nbsp;&nbsp;NumPy的统计函数4.2&nbsp;&nbsp;NumPy的梯度函数5&nbsp;&nbsp;Exercise5.1&nbsp;&nbsp;Exercise 1: Normalize a matrix5.2&nbsp;&nbsp;Exercise 2: Learn by reading document5.3&nbsp;&nbsp;Exercise 3: Clip  Numpy  Numpy简介 - NumPy是一个开源的Python科学计算机出库- 一个强大的N维数组对象 ndarray- 广播功能函数- 整合C/C++/Fortran代码得工具- 线性代数，傅里叶变化，随机数生成  ndarray - 传统计算，比较麻烦。关注点在一个一个元素上- 数组对象可以去掉元素间运算所需的循环，是一维向量更像单个数据- 设置专门的数组对象，经过优化，可以提升这类应用的运算速度- 科学计算中，一般一个维度所有的数据的类型`往往相同`- 数组对象采用相同的数据类型，有利于节省运算和存储空间- 由两部分构成    - 实际的数据    - 描述这些数据的元数据（数据维度，数据类型等）- ndarray数组一般要求所有元素类型相同，数据下标从0开始- ndarray在程序中的别名是：array- np.array()输出成[]形式，元素由空格分裂- 轴（axis）：保存数据的维度    - 矩阵（二维数组）        - 第一轴`(axis=0)`是矩阵的列操作        - 第二轴`(axis=1)`是矩阵的行操作     - 三维数组        - 第三轴`(axis=2)`为图像矩阵的通道- 秩（rank）：轴的数量 - ndarray对象的属性- ndarray的元素类型> intc与计算机有关> 实部(.real)+ j虚部(.imag)> 科学计算涉及数据较多,对存储和性能都有较高要求。>> 对元素类型精细定义,有助于 NumPy合理使用存储空间并优化性能。>> 对元素类型精细定义,有助于程序员对程序规模有合理评估。- ndarray数组可以由非同质对象构成    - 非同质ndarray元素为对象类型    - 非同质ndarray对象无法有效发挥NumPy优势，尽量避免使用  ndarray数组的创建和变换  从Python中的列表、元组等类型创建ndarray数组。   > 当不指定dtype时，NumPy将根据数据情况关联一个dtype类型   >   > 元组和列表混合类型创建<jupyter_code>import numpy as np
li = [1, 2, 3, 4]
x = np.array(li)
print(x)
x = np.array(li, dtype=np.float32)
print(x)<jupyter_output>[1 2 3 4]
[1. 2. 3. 4.]<jupyter_text>使用 NumPy中函数创建ndarray数组,如: arange, ones, zeros等  - 最常用的函数              > 除了arrage其余生成都是浮点数类型<jupyter_code>print(np.zeros((2, 3)))
print(np.zeros((2, 3), dtype=int))
np.linspace(start=10, stop=20, num=10, endpoint=True, retstep=False, dtype=int, axis=-1)<jupyter_output><empty_output><jupyter_text>> start: 返回样本数据开始点>> stop:返回样本数据结束点>> num:生成的样本数据量，默认为50>> endpoint：True则包含stop；False则不包含stop>> retstep：If True, return (samples, step), where step is the spacing between samples.(即如果为True则结果会给出数据间隔)>> dtype：输出数组类型>> axis：0(默认)或-1> linspace生成的默认为浮点数>> 科学计算中一般都是浮点数<jupyter_code>x = np.ones((2, 3), dtype=int)
y = np.zeros((2, 3), dtype=int)
print(np.concatenate((x, y), axis=0))
print(np.concatenate((x, y), axis=1))<jupyter_output>[[1 1 1]
 [1 1 1]
 [0 0 0]
 [0 0 0]]
[[1 1 1 0 0 0]
 [1 1 1 0 0 0]]<jupyter_text>ndarray数组的变换  ndarray数组的维度变换   - ndarray数组的维度变换方法          > resize和reshape功能一致     >     > resize返回的是之前的数组，形成一个新的数组     >     > reshape不改变原数组，包含原数组的备份<jupyter_code>y = np.arange(1, 100, 3)
print(y)
y = y.reshape((3, -1))
print(y)
y = y.reshape((-1, 3))
print(y)
y = y.swapaxes(0, 1)
print(y)
y = y.flatten()
print(y)<jupyter_output>[ 1  4  7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70
 73 76 79 82 85 88 91 94 97]
[[ 1  4  7 10 13 16 19 22 25 28 31]
 [34 37 40 43 46 49 52 55 58 61 64]
 [67 70 73 76 79 82 85 88 91 94 97]]
[[ 1  4  7]
 [10 13 16]
 [19 22 25]
 [28 31 34]
 [37 40 43]
 [46 49 52]
 [55 58 61]
 [64 67 70]
 [73 76 79]
 [82 85 88]
 [91 94 97]]
[[ 1 10 19 28 37 46 55 64 73 82 91]
 [ 4 13 22 31 40 49 58 67 76 85 94]
 [ 7 16 25 34 43 52 61 70 79 88 97]]
[ 1 10 19 28 37 46 55 64 73 82 91  4 13 22 31 40 49 58 67 76 85 94  7 16
 25 34 43 52 61 70 79 88 97]<jupyter_text>- mat (or array).reshape(c, -1) 必须是矩阵格式或者数组格式，才能使用 .reshape(c, -1) 函数， 表示将此矩阵或者数组重组，以 c行d列的形式表示- reshape(m,-1) 改变维度为每一列m行- reshape(-1,m) 改变维度为每一行m列- -1的作用: 自动计算d：d=数组或者矩阵里面所有的元素个数/c, d必须是整数，不然报错）  ndarray数组的类型变换<jupyter_code>x = y.astype(float)
print(x)<jupyter_output>[ 1. 10. 19. 28. 37. 46. 55. 64. 73. 82. 91.  4. 13. 22. 31. 40. 49. 58.
 67. 76. 85. 94.  7. 16. 25. 34. 43. 52. 61. 70. 79. 88. 97.]<jupyter_text>> astype()是一定会创建一个新的数组（原始数据的一个拷贝） - ndarray向list转换<jupyter_code>ls = x.tolist()
print(ls)<jupyter_output>[1.0, 10.0, 19.0, 28.0, 37.0, 46.0, 55.0, 64.0, 73.0, 82.0, 91.0, 4.0, 13.0, 22.0, 31.0, 40.0, 49.0, 58.0, 67.0, 76.0, 85.0, 94.0, 7.0, 16.0, 25.0, 34.0, 43.0, 52.0, 61.0, 70.0, 79.0, 88.0, 97.0]<jupyter_text>> list的速度可能会比numpy慢  ndarray数组的操作  数组的索引和切片 - 索引:获取数组中特定位置元素的过程- 切片:获取数组元素子集的过程 - 一维数组的索引和切片   - 与python类似- 多维数组的索引   - 索引：在每个维度指定序号<jupyter_code>a = np.arange(24).reshape((2, 3, 4))
print(a)
print(a[1, 2, 3])<jupyter_output>[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
23<jupyter_text>- 切片<jupyter_code>print(a[:, 1, -3])
print(a[:, 1, ::2])
print(a[:, :, ::2])<jupyter_output>[ 5 17]
[[ 4  6]
 [16 18]]
[[[ 0  2]
  [ 4  6]
  [ 8 10]]

 [[12 14]
  [16 18]
  [20 22]]]<jupyter_text>- 索引一维数组<jupyter_code>x = np.arange(10,1,-1)
print(x)
print(x[np.array([3, 3, 1, 8])])<jupyter_output>[10  9  8  7  6  5  4  3  2]
[7 7 9 2]<jupyter_text>> 索引数组必须为整数类型。数组中的每个值指示数组中要使用哪个值来代替索引。<jupyter_code>print(x[np.array([[1,1],[2,3]])])<jupyter_output>[[9 9]
 [8 7]]<jupyter_text>> 一般来说，使用索引数组时返回的数组是与索引数组形状相同的数组，但数组的类型和值正在编制索引。 - 索引多维数组<jupyter_code>y=np.arange(35).reshape(5,7)
print(y)
print(y[np.array([0,2,4]),np.array([0,1,2])]  )  #等价于y[[0,2,4],[0,1,2]]<jupyter_output>[[ 0  1  2  3  4  5  6]
 [ 7  8  9 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]]
[ 0 15 30]<jupyter_text>> 在这种情况下，如果索引数组具有匹配的形状，并且要编制索引的数组的每个维度都有一个索引数组，则结果数组的形状与索引数组相同，并且这些值对应于索引数组中每个位置的索引集。在此示例中，两个索引数组的第一个索引值为 0，因此结果数组的第一个值是 y[0，0]。下一个值是 y[2，1]，最后一个值是 y[4，2]。<jupyter_code>y[np.array([0,2,4]), np.array([0,1])]<jupyter_output><empty_output><jupyter_text>> 如果索引数组没有相同的形状，则尝试将它们广播到相同的形状。如果无法广播到相同形状，则引发异常<jupyter_code>y[np.array([0,2,4]), 1]<jupyter_output><empty_output><jupyter_text>> 广播机制允许索引数组与其他索引的标量组合。其效果是，标量值用于索引数组的所有相应值<jupyter_code>y[np.array([0,2,4])]<jupyter_output><empty_output><jupyter_text>> 结果是构建一个新数组，其中索引数组的每个值从被索引的数组中选择一行，生成的数组具有生成的形状(索引元素的数量、行大小)。 - Boolean or “mask” index arrays<jupyter_code>b = y > 20
print(b)
print(y[b])<jupyter_output>[[False False False False False False False]
 [False False False False False False False]
 [False False False False False False False]
 [ True  True  True  True  True  True  True]
 [ True  True  True  True  True  True  True]]
[21 22 23 24 25 26 27 28 29 30 31 32 33 34]<jupyter_text>> 整数索引数组不同，在布尔的情况下，结果是一个一维数组，其中包含索引数组中对应于布尔数组中所有真实元素的所有元素。<jupyter_code>print(b[:, 5])
print(y[b[:, 5]])<jupyter_output>[False False False  True  True]
[[21 22 23 24 25 26 27]
 [28 29 30 31 32 33 34]]<jupyter_text>> In general, when the boolean array has fewer dimensions than the array being indexed, this is equivalent to y[b, ...], which means y is indexed by b followed by as many : as are needed to fill out the rank of y. Thus the shape of the result is one dimension containing the number of True elements of the boolean array, followed by the remaining dimensions of the array being indexed.<jupyter_code>x = np.arange(30).reshape(2, 3, 5)
print(x)
print('-'*50)
b = np.array([[True, True, False], [False, True, True]])
print(x[b])<jupyter_output>[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]
  [10 11 12 13 14]]

 [[15 16 17 18 19]
  [20 21 22 23 24]
  [25 26 27 28 29]]]
--------------------------------------------------
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [20 21 22 23 24]
 [25 26 27 28 29]]<jupyter_text>ndarray数组的运算 1. 数组与标量之间的运算   - 作用于数组的每一个元素      > a.mean() 求一个数组的平均值   - NumPy一元函数          > ceil 不超过这个元素的整数值     >     > floor 小于这个元素的最大整数值     2. 二元函数   - 二元函数<jupyter_code>x = np.arange(10)
y = np.arange(10, 20)
print(x, y, x + y, sep='\n')
# Apply a function to a matrix

# power of 2
print(np.power(x, 2))
# sin
print(np.sin(x))
# square root
print(np.sqrt(x))
x = np.arange(15, dtype=float)
x = x.reshape((3, -1))
x[:2, 1:3] *= -1
x
# Check element-wise
print(x > 0)<jupyter_output>[[False False False  True  True]
 [ True False False  True  True]
 [ True  True  True  True  True]]<jupyter_text>NumPy的随机数函数 1. np.random的随机数函数   -      > seed()设定为一个值之后，使用上面的函数再次产生纬度和类型的随机数，结果是相同的     >     > seed()只能是一次有效   -      > p可以是一个数组   -   NumPy的统计函数1. np常用的统计函数   -      > 可以指定对某个轴进行统计运算     >     > 数组最外层，轴为0<jupyter_code>a = np.arange(15).reshape(3, 5)
print(a)
print('-'*50)
print(np.mean(a, axis=0))
print('-'*50)
print(np.mean(a, axis=1))<jupyter_output>[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
--------------------------------------------------
[5. 6. 7. 8. 9.]
--------------------------------------------------
[ 2.  7. 12.]<jupyter_text><jupyter_code>print(np.argmax(a))
print(np.unravel_index(np.argmax(a), a.shape))<jupyter_output>14
(2, 4)<jupyter_text>NumPy的梯度函数 1. 梯度   - 连虚值之间的变化率，即斜率    > 计算数组f中元素的梯度，当f为多维时，返回每个维度梯度    >    > XY坐标轴连续三个X坐标对应的Y轴值：a, b, c, 其中，b的梯度是：(c - a)/2，a的梯度是：(b - a)/1，c的梯度是：(b - c)/2<jupyter_code>a = np.random.randint(0, 20, 5)
print(a)
print('-'*50)
print(np.gradient(a))
import pprint
c = np.random.randint(0, 50, (3, 5))
print(c)
print('-'*50)
d = np.gradient(c)
pprint.pprint(d)<jupyter_output>[[12 32 34 18 23]
 [46  9 48 32  2]
 [24 13 30 25 47]]
--------------------------------------------------
[array([[ 34. , -23. ,  14. ,  14. , -21. ],
       [  6. ,  -9.5,  -2. ,   3.5,  12. ],
       [-22. ,   4. , -18. ,  -7. ,  45. ]]),
 array([[ 20. ,  11. ,  -7. ,  -5.5,   5. ],
       [-37. ,   1. ,  11.5, -23. , -30. ],
       [-11. ,   3. ,   6. ,   8.5,  22. ]])]
{'fraction_non_alphanumeric': 0.18548909522781257, 'fraction_numerical': 0.11995249406175772, 'mean_word_length': 3.603876739562624, 'pattern_counts': {'":': 0, '<': 68, '<?xml version=': 0, '>': 126, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '21', 'dir': 'jupyter-structured-clean-dedup', 'id': '420826', 'license': 'MIT', 'n_tokens_mistral': 5921, 'n_tokens_neox': 5429, 'n_words': 975, 'path': 'Tutorial10/Numpy_zh.ipynb', 'repo_name': 'Yang-lin-09/Python-Learing-Notes', 'size': '9262'}