<jupyter_start><jupyter_text>[教程](http://www.naodongopen.com/272.html)<jupyter_code>import numpy as np
import matplotlib.pyplot as plt<jupyter_output><empty_output><jupyter_text>名称	  作用ndarray.flags	有关数组的内存布局的信息。ndarray.shape	数组维数组。ndarray.strides	遍历数组时，在每个维度中步进的字节数组。ndarray.ndim	数组维数，在Python世界中，维度的数量被称为rank。ndarray.data	Python缓冲区对象指向数组的数据的开始。ndarray.size	数组中的元素总个数。ndarray.itemsize	一个数组元素的长度（以字节为单位）。ndarray.nbytes	数组的元素消耗的总字节数。ndarray.base	如果内存是来自某个其他对象的基本对象。ndarray.dtype	数组元素的数据类型。ndarray.T	   数组的转置。<jupyter_code>a = np.arange(9)
b = a.reshape(3, 3)
b.size
b.flags
b.T
a = np.array([(2, 3, 4), (5, 6, 7)], dtype=np.uint64)
a.astype(np.bool_)
np.uint64([1, 2, 3])
a = np.arange(24)
a
a = np.arange(10)
a.resize(2, 5)
a
a[1][::2]
a = np.arange(10, 0, -1)
# a.resize(2,5)
a[np.array([3, 3, 1, 8])]
a = np.arange(35)
a.resize(5, 7)
a<jupyter_output><empty_output><jupyter_text>等比数列，参数为点个数<jupyter_code>N = 8
y = np.zeros(N)
x1 = np.linspace(0, 10, N, endpoint=True)
x2 = np.linspace(0, 10, N, endpoint=False)
plt.plot(x1, y, 'o')
plt.plot(x2, y + 0.5, 'o')
plt.ylim([-.5, 1])
plt.show()<jupyter_output><empty_output><jupyter_text>等差数列， 参数为点个数, base=10np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)``开始：base ** start``<jupyter_code>np.logspace(2.0, 3.0, num=4)
np.logspace(2.0, 3.0, num=4, endpoint=False)
np.logspace(2.0, 3.0, num=4, base=2.0)
np.logspace(0.1, 1, N, endpoint=True)
N = 10
y1 = np.logspace(0.1, 1, N, endpoint=True)
y2 = np.logspace(0.1, 1, N, endpoint=True)
x = np.arange(
    0,
    10,
)
plt.plot(x, y1, 'o')
plt.plot(x + 0.5, y2, '^')
# plt.ylim([0, 1])
plt.show()<jupyter_output><empty_output><jupyter_text>数据大小<jupyter_code>a = np.arange(5)
a.dtype = np.float16
a.dtype
a = np.arange(5)
np.float16(a)
np.dtype([("name", np.str_, 40), ("numitems", np.int64), ("price",
                                                          np.float64)])<jupyter_output><empty_output><jupyter_text>索引  单个元素<jupyter_code>arr = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
arr[0, 1]<jupyter_output><empty_output><jupyter_text>取连续，用切片<jupyter_code>arr[0, 3:5]<jupyter_output><empty_output><jupyter_text>不连续，用元组<jupyter_code>arr[([0, 1, 2], [1, 2, 3])]
arr[1:, (0, 2, 3)]<jupyter_output><empty_output><jupyter_text>布尔索引<jupyter_code>mask = np.array([1, 0, 1], dtype=np.bool)
arr<jupyter_output><empty_output><jupyter_text>改变数组形状<jupyter_code>arr = np.arange(12)
arr.reshape((3, 4))  # 有返回值
arr.resize((3, 4))  # 不返回值，在原数组上该变
arr<jupyter_output><empty_output><jupyter_text>使用ravel函数展平数组<jupyter_code>arr = np.arange(12).reshape(3, 4)
arr
arr.ravel()  # 原数组不变
arr<jupyter_output><empty_output><jupyter_text>横向展平（行优先）<jupyter_code>arr.flatten()<jupyter_output><empty_output><jupyter_text>纵向展平（列优先）<jupyter_code>arr.flatten('F')<jupyter_output><empty_output><jupyter_text>数组组合 - 使用hstack函数实现数组横向组合：np.hstack((arr1,arr2))- 使用vstack函数实现数组纵向组合：np.vstack((arr1,arr2))- 使用concatenate函数实现数组横向组合：np.concatenate((arr1,arr2),axis = 1))- 使用concatenate函数实现数组纵向组合：np.concatenate((arr1,arr2),axis = 0))  切割数组 - 使用hsplit函数实现数组横向分割： np.hsplit(arr1, 2)- 使用vsplit函数实现数组纵向分割： np.vsplit(arr, 2)- 使用split函数实现数组横向分割： np.split(arr, 2, axis=1)- 使用split函数实现数组纵向分割： np.split(arr, 2, axis=0)<jupyter_code># 平均分割
x = np.arange(9.0)
np.split(x, 3)
x = np.arange(8.0)
np.split(x, [3, 5, 6, 10, 20])  # 分成6份,即使为空<jupyter_output><empty_output><jupyter_text>创建与组合矩阵  1<jupyter_code># Interpret the input as a matrix
#Equivalent to ``matrix(data, copy=False)
matr1 = np.mat("1 2 3;4 5 6;7 8 9")
matr1<jupyter_output><empty_output><jupyter_text>2<jupyter_code>matr2 = np.matrix([[123], [456], [789]])
matr2<jupyter_output><empty_output><jupyter_text>使用bmat函数合成矩阵：（分块矩阵组合）<jupyter_code>A = np.mat('1 1; 1 1')
B = np.mat('2 2; 2 2')
C = np.mat('3 4; 5 6')
D = np.mat('7 8; 9 0')
np.bmat([[A, B], [C, D]])
np.c_[A, B]
np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])
np.bmat('A,B; C,D')<jupyter_output><empty_output><jupyter_text>矩阵的运算  矩阵与数相乘：<jupyter_code>matr1 = np.arange(0, 4).reshape((2, 2))
matr1
matr2 = np.arange(2, 6).reshape((2, 2))
matr2
matr1 * 3<jupyter_output><empty_output><jupyter_text>矩阵相加减：<jupyter_code>matr1 + matr2<jupyter_output><empty_output><jupyter_text>矩阵相乘：<jupyter_code>matr1 * matr2<jupyter_output><empty_output><jupyter_text>矩阵对应元素相乘：<jupyter_code>np.multiply(matr1, matr2)<jupyter_output><empty_output><jupyter_text>|属性     |说明||----------|------||T| 返回自身的转置 ||H| 返回自身的共轭转置||I|返回自身的逆矩阵||A|返回自身数据的2维数组的一个视图|  认识ufunc函数 **全称通用函数（universal function），是一种能够对数组中所有元素进行操作的函数。** -  四则运算：加（+）、减（-）、乘（*）、除（/）、幂（**）。数组间的四则运算表示对每个数组中的元素分别进行四则运算，所以形状必须相同。 - 比较运算：>、=、<=、!=。比较运算返回的结果是一个布尔数组，每个元素为每个数组对应元素的比较结果。- 逻辑运算：np.any函数表示逻辑“or”，np.all函数表示逻辑“and”。运算结果返回布尔值。 ** ufunc函数的广播机制:**广播（broadcasting）是指不同形状的数组之间执行算术运算的方式。需要遵循4个原则。- 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐。- 输出数组的shape是输入数组shape的各个轴上的最大值。- 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错。- 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值  读写文件 **- save函数是以二进制的格式保存数据。 np.save("../tmp/save_arr",arr)****- load函数是从二进制的文件中读取数据。 np.load("../tmp/save_arr.npy") ****- savez函数可以将多个数组保存到一个文件中。 np.savez('../tmp/savez_arr',arr1,arr2)****- 存储时可以省略扩展名，但读取时不能省略扩展名。 ** **savetxt函数是将数组写到某种分隔符隔开的文本文件中。      np.savetxt("../tmp/arr.txt", arr, fmt="%d", delimiter=",")****loadtxt函数执行的是把文件加载到一个二维数组中。      np.loadtxt("../tmp/arr.txt",delimiter=",")****genfromtxt函数面向的是结构化数组和缺失数据。      np.genfromtxt("../tmp/arr.txt", delimiter = ",")**  排序  直接排序 sort函数是最常用的排序方法。 arr.sort()sort函数也可以指定一个axis参数，使得sort函数可以沿着指定轴对数据集进行排序。axis=1为沿横轴排序； axis=0为沿纵轴排序<jupyter_code>np.random.seed(42)  #设置随机种子
arr = np.random.randint(1, 10, size=10)  #生成随机数
print('创建的数组为：', arr)
arr.sort()  #直接排序
print('排序后数组为：', arr)
arr = np.random.randint(1, 10, size=(3, 3))  #生成3行3列的随机数
print('创建的数组为：\n', arr)
arr.sort(axis=1)  #沿着横轴排序
print('排序后数组为：\n', arr)
arr.sort(axis=0)  #沿着纵轴排序
print('排序后数组为：\n', arr)<jupyter_output>排序后数组为：
 [[2 4 5]
 [2 7 8]
 [3 9 9]]<jupyter_text>间接排序 argsort函数返回值为重新排序值的**下标**。 arr.argsort()lexsort函数返回值是按照最后一个传入数据排序的。 np.lexsort((a,b,c))<jupyter_code>arr = np.array([2, 3, 6, 8, 0, 7])
print('创建的数组为：\n', arr)
print('排序后数组为：\n', arr.argsort())  #返回值为重新排序值的下标
a = np.array([3, 2, 6, 4, 5])
b = np.array([50, 30, 40, 20, 10])
c = np.array([400, 300, 600, 100, 200])
d = np.lexsort((a, b, c))  #lexsort函数只接受一个参数，即（a,b,c）,返回下标
d
a[d], b[d], c[d]
# 相当于
a[c.argsort()], b[c.argsort()], c[c.argsort()]
#多个键值排序是按照最后一个传入数据计算的
print('排序后数组为：\n', list(zip(a[d], b[d], c[d])))<jupyter_output>排序后数组为：
 [(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]<jupyter_text>去重  unique函数<jupyter_code>names = np.array(['小明', '小黄', '小花', '小明', '小花', '小兰', '小白'])
print('创建的数组为：', names)
print('去重后的数组为：', np.unique(names))
#跟np.unique等价的Python代码实现过程
print('去重后的数组为：', sorted(set(names)))
ints = np.array([1, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 10])  #创建数值型数据
print('创建的数组为：', ints)
print('去重后的数组为：', np.unique(ints))<jupyter_output>创建的数组为： [ 1  2  3  4  4  5  6  6  7  8  8  9 10]
去重后的数组为： [ 1  2  3  4  5  6  7  8  9 10]<jupyter_text>tile函数<jupyter_code>arr = np.arange(5)
print('创建的数组为：', arr)
print('重复后数组为：', np.tile(arr, 3))  #对数组进行重复
arr.tolist() * 3
arr * 3<jupyter_output><empty_output><jupyter_text>repeat函数<jupyter_code>np.random.seed(42)  #设置随机种子
arr = np.random.randint(0, 10, size=(3, 3))
print('创建的数组为：\n', arr)
print('重复后数组为：\n', arr.repeat(2, axis=0))  #按行进行元素重复
print('重复后数组为：\n', arr.repeat(2, axis=1))  #按列进行元素重复<jupyter_output>重复后数组为：
 [[6 6 3 3 7 7]
 [4 4 6 6 9 9]
 [2 2 6 6 7 7]]<jupyter_text>**这两个函数的主要区别在于，tile函数是对数组进行重复操作，repeat函数是对数组中的每个元素进行重复操作。**  常用的统计函数 |函数	|说明||-------|---------||sum	|计算数组的和||mean	|计算数组均值||std	|计算数组标准差||var	|计算数组方差||min|	计算数组最小值||max|	计算数组最大值||argmin	|返回数组最小元素的索引||argmax	|返回数组最小元素的索引||cumsum	|计算所有元素的累计和||cumprod	|计算所有元素的累计积|<jupyter_code>arr = np.arange(20).reshape(4,5)
print('创建的数组为：',arr)
print('数组的和为：',np.sum(arr))  #计算数组的和
print('数组横轴的和为：',arr.sum(axis = 0))  #沿着横轴计算求和
print('数组纵轴的和为：',arr.sum(axis = 1))  #沿着纵轴计算求和
print('数组的均值为：',np.mean(arr))  #计算数组均值
print('数组横轴的均值为：',arr.mean(axis = 0))  #沿着横轴计算数组均值
print('数组纵轴的均值为：',arr.mean(axis = 1))  #沿着纵轴计算数组均值
print('数组的标准差为：',np.std(arr))  #计算数组标准差
print('数组的方差为：',np.var(arr))  #计算数组方差
print('数组的最小值为：',np.min(arr))  #计算数组最小值
print('数组的最大值为：',np.max(arr))  #计算数组最大值
print('数组的最小元素为：',np.argmin(arr))  #返回数组最小元素的索引
print('数组的最大元素为：',np.argmax(arr))  #返回数组最大元素的索引
arr = np.arange(2,10)
print('创建的数组为：',arr)
print('数组元素的累计和为：',np.cumsum(arr))  #计算所有元素的累计和
print('数组元素的累计积为：',np.cumprod(arr))  #计算所有元素的累计积<jupyter_output>创建的数组为： [2 3 4 5 6 7 8 9]
数组元素的累计和为： [ 2  5  9 14 20 27 35 44]
数组元素的累计积为： [     2      6     24    120    720   5040  40320 362880]<jupyter_text>Nothing<jupyter_code>b = a[:, np.newaxis, :]
b.shape, b
a = np.arange(5)
a[:, np.newaxis].shape
a[np.newaxis, :].shape
a = np.arange(81).reshape(3, 3, 3, 3)
a
print(a[1, ..., 2], '\n----\n', a[1, :, :, 2])
a = np.arange(6)
a.shape = (2, 1, 3)
a.squeeze()
x = np.random.randint(20, size=60).reshape(3, 4, 5)
x
np.argmax(x, axis=0)
a = np.arange(0, 40, 10)

a = a[:, np.newaxis]  # 转换a的维度（形状）
print(a)
np.array(([i * 3 for i in a.tolist()]))
a.tolist() * 3
a = [1, 2, 3]
a * 3
x = np.array(
    [('Bob', 18, 2000.0), ('Tom', 23, 4000.0)],
    dtype=[('name', np.str_), ('age', np.int_), ('incom', np.float_)])
x
x[:][0]
import numpy.ma as ma
ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])<jupyter_output><empty_output><jupyter_text>[掩码](http://www.naodongopen.com/290.html)<jupyter_code>a = ma.masked_array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
a
a[~a.mask]
a.compressed()
x = np.ma.array(np.arange(5), mask=[0] * 2 + [1] * 3)
x
x.compressed()<jupyter_output><empty_output><jupyter_text>[修改掩码](http://www.naodongopen.com/290.html)  genfromtxt函数<jupyter_code>from io import BytesIO
data = "1, 2, 3\n4, 5, 6"
#StringIO:在内存中读写str
from io import StringIO
f = StringIO()

print(f.write('hello'))
print(f.write(' '))
print(f.write('world!'))
f.getvalue()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.21365794524699463, 'fraction_numerical': 0.05657137084553995, 'mean_word_length': 6.173913043478261, 'pattern_counts': {'":': 0, '<': 117, '<?xml version=': 0, '>': 117, 'https://': 0, 'lorem ipsum': 0, 'www.': 3, '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': '30', 'dir': 'jupyter-structured-clean-dedup', 'id': '158726', 'license': 'MIT', 'n_tokens_mistral': 6078, 'n_tokens_neox': 6091, 'n_words': 742, 'path': 'numpy.ipynb', 'repo_name': 'ComeMorning/Modules-Learn', 'size': '9899'}