import numpy as np

1. ndarray数组的创建方法

1、从Python中的列表、元祖等类型创建ndarray数组
“x=np.array(list/tuple,dtype=? )”当np.array()不指定dtype时，numpy将根据数据情况关联一个dtype类型。

import numpy as np
x=np.array([0,1,2,3])
print(x)
x=np.array([(0,1),[2,3],(0.3,0.4)])
print(x)输出结果如下：
[0 1 2 3][[0.  1. ][2.  3. ][0.3 0.4]]

2、使用numpy中函数创建ndarray数组

np.arange(n)：类似range函数，返回ndarray类型，元素从0到n-1
np.ones(shape)：根据shape生成一个全1数组，shape是数组类型
np.zeros(shape)：根据shape生成一个全0 数组
np.full(shape,val)：根据shape生成一个数组，每个元素值都是val
np.eye(n)：创建一个正方的n*n单位矩阵，对角线为1，其余为0 np.ones_like(a)：根据数组a的形状生成一个全1数组

import numpy as np
print(np.arange(4))   #数据类型默认为整形
print(np.ones((2,3,4)))  #默认为浮点型
print(np.zeros((3,6),dtype=np.int32)) #默认为浮点型
print(np.eye(5))  #默认为浮点型输出结果分别为：
[0 1 2 3]
-----------------------------
[[[1. 1. 1. 1.][1. 1. 1. 1.][1. 1. 1. 1.]][[1. 1. 1. 1.][1. 1. 1. 1.][1. 1. 1. 1.]]]
-----------------------------
[[0 0 0 0 0 0][0 0 0 0 0 0][0 0 0 0 0 0]]
-----------------------------
[[1. 0. 0. 0. 0.][0. 1. 0. 0. 0.][0. 0. 1. 0. 0.][0. 0. 0. 1. 0.][0. 0. 0. 0. 1.]]

np.zeros_like(a)：根据数组a的形状生成一个全0数组
np.full_like(a,val)：根据数组a的形状生产一个数组，元素值都是val

3、使用numpy中其他函数创建ndarray数组

np.linspace()：根据起止数据等间距地填充数据，形成数组
np.concatenate()：将两个或多个数组合并成一个新的数组

import numpy as np
a=np.linspace(1,10,4)
print(a)
b=np.linspace(1,10,4,endpoint=False)#endpoint=false不显示最后一位数字
print(b)
c=np.concatenate((a,b))
print(c)输出结果如下：
[ 1.  4.  7. 10.][1.   3.25 5.5  7.75][ 1.    4.    7.   10.    1.    3.25  5.5   7.75]

2. ndarray数组的变换

1.维度的变换
（1）.reshape(shape) 不改变元数组，返回新维度的数组

（2）.resize(shape) 改变元数组，无返回值


（3）.flatten() 对数组降维，变为一维数组，不改变原数组

（4）swapaxes(ax1,ax2)将数组n个维度中两个维度进行调换

2.类型的变换
（1）.astype(new_type) 改变数组的数据类型，不改变原数组
np.int 表示int 类型，具体表示为哪一种int类型，根据数据的大小。

（2）.tolist() 将数组向列表转换

3. ndarray对象的属性

import  numpy#创建一位数组
a=numpy.array([1,2,3,4])
b=numpy.arange(4,10)#创建三维数组
c=numpy.random.randint(4,10,size=(3,3,4))#ndarray属性
print(c.ndim)    # 返回维度（也就是秩）
#shape属性
print(c.shape)   #打印行列数和维度
#dtype属性
print(c.dtype)
print(c.size)   #元祖里面的元素总和
#itemsize每个元素占的字节
print(c.itemsize)

4.数组的索引与切片

4. ndarray数组的运算

①数组与标量的运算


②运算函数（一元函数）

celling是不超过元素的整数的最大值，floor是超过元素的整数最小值



②运算函数（二元函数）

5. numpy的随机函数

①np.random.rand(d0, d1, …, dn)产生shape为 (d0, d1,…, dn), 值为 [0, 1) 范围内的浮点随机数

import numpy as np# 默认d0 = 1, 产生[0, 1)范围内的一个浮点随机数
a = np.random.rand() 
# d0 = 2, 产生[0, 1)范围内的一维数组（向量）的浮点随机数
b = np.random.rand(2) 
# d0 = 2, d1 = 3, 产生[0, 1)范围内的二维数组（矩阵）的浮点随机数
c = np.random.rand(2,3) print(a)
print(b)
print(c)0.575695284381402
-----------------------
[0.50852146 0.17941441]
-----------------------
[[0.07689737 0.17578407 0.16941739][0.63075319 0.86015553 0.88239051]]

②np.random.randint(low, high = None, size = None)，产生产生shape为size, 值为 [low, high) 范围内的整型随机数

import numpy as np# low = 0, high = 3, 产生[0, 3)范围内的一个整型随机数
a = np.random.randint(0, 3)
# low = 3, 产生[0, 3)范围内的一维数组（向量）的整型随机数
b = np.random.randint(3, size = 4)
# low = 0, high = 3, 产生[0, 3)范围内的二维数组（矩阵）的整型随机数
c = np.random.randint(0, 3, size = (2, 3))print(a)
print(b)
print(c)2
-----------------------
[0 2 1 1]
-----------------------
[[2 1 1][0 1 0]]

③np.random.randn(d0, d1, …, dn)产生shape为 (d0, d1,…, dn)的标准正态分布的随机数

import numpy as np# 从标准正态部分中随机采样3个随机数
a = np.random.randn(3)
# 从标准正态分布中随机采样2 × 3个随机数，组成(2, 3)的二维数组（矩阵）
b = np.random.randn(2, 3)print(a)
print(b)[ 0.2203204   1.73158706 -0.78638403]
----------------------------------------------
[[ 0.44799247 -0.37243396 -0.57481381][ 0.17644269  0.99336282 -0.55967673]]

④seed(s)随机种子值为s的随机种子

⑤np.random.normal(loc = 0.0, scale = 1.0, size = None)# 产生shape为size的正态分布
参数loc对应数学中的期望μ，μ是正态分布的位置参数，描述正态分布集中趋势位置，与μ邻近的概率值越大，而远离μ的概率值越小。正态分布以X = μ为对称轴，左右完全对称。正态分布的期望、均数、中位数、众数相同，均等于μ；
参数scale对应数学中的标准差σ，σ描述正态分布数据的离散程度，σ越大，数据的分布越分散，σ越小，数据分布越集中。σ也称为正态分布的形状参数，σ越大，曲线越扁平，反之，σ越小，曲线越高瘦；

import numpy as npmu, sigma = 0.1, 2.0
# 从μ = 0.1, σ = 2.0的正态部分中随机采样3个随机数
a = np.random.normal(mu, sigma, 3)
# 从μ = 0.1, σ = 2.0的正态部分中随机采样2 × 3个随机数，组成(2, 3)的二维数组（矩阵）
b = np.random.normal(mu, sigma, size = (2, 3))print(a)
print(b)[ 1.31578944 -1.16272895  2.50095739]
[[ 2.07134546 -0.62086584 -0.32091925][ 0.2286672  -1.13700916  0.09206429]]

⑥np.random.poisson(lam,size)产生shape为size，随机事件发生概率为lam的泊松分布
⑦np.random.uniform(low = 0.0, high = 1.0, size = None)，产生shape为size范围在[low, high)内的均匀分布

import numpy as np# 产生shape为size范围在[low, high)内的均匀分布# low = 3, 输出向量, shape = (4, )
a = np.random.uniform(3, size = 4)
# low = 0, high = 3, 输出为标量, shape = ()
b = np.random.uniform(0, 3)
# low = 0, high = 3, 输出为矩阵, shape = (2, 3)
c = np.random.uniform(0, 3, size = (2, 3))print(a)
print(b)
print(c)[2.65418547 1.65702115 2.42128949 2.74215319]
1.253105912177019
[[2.11947645 2.85662794 2.33596866][0.86552208 2.9166298  1.55980368]]

⑧

6. numpy的统计函数

②numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。

import numpy as np a = np.array([[1,2,3],[3,4,5],[4,5,6]])  print ('我们的数组是：')
print (a)
print ('\n')print ('调用 mean() 函数：')
print (np.mean(a))
print ('\n')print ('沿轴 0 调用 mean() 函数：')
print (np.mean(a, axis =  0))
print ('\n')print ('沿轴 1 调用 mean() 函数：')
print (np.mean(a, axis =  1))

③numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。
数组[1,2,3,4]和相应的权重[4,3,2,1]，加权平均值 = (14+23+32+41)/(4+3+2+1)

import numpy as np a = np.array([1,2,3,4])  
print ('我们的数组是：')
print (a)
print ('\n')print ('调用 average() 函数：')
print (np.average(a))
print ('\n')
# 不指定权重时相当于 mean 函数wts = np.array([4,3,2,1])  
print ('再次调用 average() 函数：')
print (np.average(a,weights = wts))
print ('\n')# 如果 returned 参数设为 true，则返回权重的和  
print ('权重的和：')
print (np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))

在多维数组中，可以指定用于计算的轴。

import numpy as np a = np.arange(6).reshape(3,2)  
print ('我们的数组是：')
print (a)
print ('\n')print ('修改后的数组：')
wt = np.array([3,5])  
print (np.average(a, axis =  1, weights = wt))
print ('\n')print ('修改后的数组：')
print (np.average(a, axis =  1, weights = wt, returned =  True))

④np.std()标准差是方差的算术平方根。
std = sqrt(mean((x - x.mean())2))

⑤np.var()统计中的标准差是方差的平方根。方差 mean((x - x.mean()) 2)

⑥

7. numpy的梯度函数

8. numpy的存储与读取

①二维数组的存储与读取









②多维数组的存储与读取

末》numpy库应用的摘抄（极其重要，务必精熟）
1.if-else的简写

1.通常写法b=4
if b>4:print('对了')
else:print('错了')2.简写'对了' if b>4 else '错了'

2.for in循环的简写

q=[(a,b) for a in range(10) for b in range(10) if a>0 and a%2==0 and b%2==0]这条语句的阅读顺序是 for a in range(10) --> for b in range(10) -->if a>0 and a%2==0 and b%2==0 -->(a,b)
也就是说for in 和if else组合在一起时就是从前往后读

q=[(a,b) for a in range(10) for b in range(10) if a>0 and a%2==0 and b%2==0]print(q)
# [(2, 0), (2, 2), (2, 4), (2, 6), (2, 8), (4, 0), (4, 2), (4, 4), (4, 6), (4, 8), (6, 0), (6, 2), (6, 4), (6, 6), (6, 8), (8, 0), (8, 2), (8, 4), (8, 6), (8, 8)]

q=[(a+b) for a in range(10) for b in range(10) if a>0 and a%2==0 and b%2==0]print(q)
# [2, 4, 6, 8, 10, 4, 6, 8, 10, 12, 6, 8, 10, 12, 14, 8, 10, 12, 14, 16]

3.reshape(-1)

import numpy as np
c=np.array([[1,2,3],[4,5,6]])
print('两行三列')
print(c.reshape(2,3))
[[1 2 3][4 5 6]]print('三行两列')
print(c.reshape(3,2))
[[1 2][3 4][5 6]]print('我也不知道是几行，反正就是1列')
print(c.reshape(-1,1))
[[1][2][3][4][5][6]]print('我也不知道是几列，反正就是1行')
print(c.reshape(1,-1))
[[1 2 3 4 5 6]]print('不分行列，就是一串数字')
print(c.reshape(-1))
[1 2 3 4 5 6]

z = np.array([[1, 2, 3, 4],  [5, 6, 7,8],  [9, 10, 11, 12],  [13, 14, 15, 16]])
print(z.reshape(-1)) 
输出：[ 1 2  3  4  5  6  7  8  9 10 11 12 13 14 15 16] ```

import networkx as nx
import numpy as np
G=nx.graph_atlas(100)aa=[[nx.shortest_path_length(G,i,j) for j in G if i != j]for i in G]
bb=np.array([[nx.shortest_path_length(G,i,j) for j in G if i != j]for i in G])
cc=np.array([[nx.shortest_path_length(G,i,j) for j in G if i != j]for i in G]).reshape(-1)
dd=[nx.shortest_path_length(G,i,j) for i in G for j in G  if i != j]
print(aa)
print(bb)
print(cc)
print(dd)