numpy的几种属性
ndm 维度
shape 行数和列数 ，准确来说时形状，可能会有二维以上的array 以元组的形式返回或使用
size array的行数和列数
np.array()
将列表转换成array
import numpy as np
array = np.array([1,2,3])
print(array.ndim)
print(array.shape)
print(array.size)
输出 ：
[1 2 3]
1
(3,)
3
Numpy的创建array
array：创建数组
dtype：指定数据类型
zeros：创建数据全为0
ones：创建数据全为1
empty：创建数据接近0
arrange：按指定范围创建数据
linspace：创建线段
指定数据 dtype
创建时的第二个参数 可以为np.int np.int 64 np.float
a = np.array([2,23,4],dtype=np.int)
print(a.dtype)
# int 64
a = np.array([2,23,4],dtype=np.int32)
print(a.dtype)
# int32
a = np.array([2,23,4],dtype=np.float)
print(a.dtype)
# float64
a = np.array([2,23,4],dtype=np.float32)
print(a.dtype)
# float32
创建特定数据的array
注意size是个元组 括号的形式，在传递size参数的时候需要加上括号
np.zeors( size) 下同
np.ones()
np.empty() 占位，里面的值是随机的
np.arrange() 创建连续的数组 ，单独一个参数的话就是0~a-1的来连续数组 如果有两个参数的话就是a-b-1的连续数组，步长为1，若是三个参数的话。就是a到b之间步长为c的一个数组
np.linspace(1,10,20) 创建线段行数据 # 开始端1，结束端10，且分割成20个数据，生成线段
array.reshape(size) 改变形状，返回一个对象，但是array本身的值不会改变
numpy的几种基本运算
加减 判断 幂运算
import numpy as np
a=np.array([10,20,30,40]) # array([10, 20, 30, 40])
b=np.arange(4) # array([0, 1, 2, 3])
c=a-b # array([10, 19, 28, 37])
c=a+b # array([10, 21, 32, 43])
c=a*b # array([ 0, 20, 60, 120])
c=b**2 # array([0, 1, 4, 9]) #python中的乘方表示方法
c=10*np.sin(a)
print(b<3) #逻辑判断 会吧每个位置上的元素映射长true or false
c_dot = np.dot(a,b) # 矩阵乘法，左乘与右乘不同
c_dot = a.dot(b) #方法同上
求和 均值 最大最小值等等
import numpy as np
a=np.random.random((2,4))
print(a)
# array([[ 0.94692159, 0.20821798, 0.35339414, 0.2805278 ],
# [ 0.04836775, 0.04023552, 0.44091941, 0.21665268]])
#对整个array的维度上操作
np.sum(a) # 4.4043622002745959
np.min(a) # 0.23651223533671784
np.max(a) # 0.90438450240606416
np.mean(A) #求平均值
A.mean() #是一种array的方法 同上 但是没有A.average()
np.average(A) #另一种方法 .
A.median() #求中位数
#指定维度的操作方法 只当axis axis=0就是在第0个维度上操作 =1就是在底一个维度上操作 （对应二维情况就是 0表示对行操作 1表示对列操作
print("a =",a)
# a = [[ 0.23651224 0.41900661 0.84869417 0.46456022]
# [ 0.60771087 0.9043845 0.36603285 0.55746074]]
print("sum =",np.sum(a,axis=1))
# sum = [ 1.96877324 2.43558896]
print("min =",np.min(a,axis=0))
# min = [ 0.23651224 0.41900661 0.36603285 0.46456022]
print("max =",np.max(a,axis=1))
# max = [ 0.84869417 0.9043845 ]
关于numpy中的维度参数axis axis这个参数很有趣 我们可以理解为我们想要干掉的维度，计算会在这个维度上进行，把这个维度的size压缩为1（1也可以理解为这个维度消失了）。这个理解方式对我们之后理解axis相关的操作非常重要 比如原来的shape为（2，3，4） 在axis = 0上求和后结果的shape为（3，4）
import numpy as np
a = np.arange(24).reshape(2,3,4)
print(a)
print("axis = 0",np.sum(a,0))
print("axis = 1",np.sum(a,1))
print("axis = 2",np.sum(a,2))
# [[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
# axis = 0 [[12 14 16 18]
# [20 22 24 26]
# [28 30 32 34]]
# 在第零个维度上 做求和 即 12 = 0 + 12 14 = 1 + 13
#结果的每一个数 都是a在这个维度上的size的个数个元素的和 0维上2个
#结果的size为（3，4）
# axis = 1 [[12 15 18 21]
# [48 51 54 57]]
# 在第二个维度上求和 12 = 0+4+8 15 = 1+5+9 3个元素
# axis = 2 [[ 6 22 38]
# [54 70 86]]
#同理
求索引的几种运算
np.argmin(A)
np.argmax(A)
**np.cumsum()**累加
A.flatten() 展平，返回值是一个对象
A.flat 展平 是一个迭代器 一个属性而不是方法
返回值是一个整数，对应A转变为一维array后所求原始的索引
np.nonzero(A)) 返回非零元素的索引，列表形式的返回
flatten是一个展开性质的函数，将多维的矩阵进行展开成1行的数列。而flat是一个迭代器，本身是一个object属性。
import numpy as np
A = np.arange(2, 14).reshape((3, 4))
# array([[ 2, 3, 4, 5]
# [ 6, 7, 8, 9]
# [10,11,12,13]])
print(np.argmin(A)) # 0
print(np.argmax(A)) # 11
print(A.flatten())
print(A.flat[np.argmin(A)])
print(A.flat[np.argmax(A)])
# 0
# 11
# [ 2 3 4 5 6 7 8 9 10 11 12 13]
# 2
# 13
import numpy as np
A = np.arange(2,14).reshape((3,4))
# array([[ 2, 3, 4, 5]
# [ 6, 7, 8, 9]
# [10,11,12,13]])
print(np.cumsum(A)) #变成一维 flat后的累加
# [2 5 9 14 20 27 35 44 54 65 77 90]
print(np.diff(A)) #列减少一列 是每一咧（最后一个维度的累差）
# [[1 1 1]
# [1 1 1]
# [1 1 1]]
print(np.nonzero(A))
# (array([0,0,0,0,1,1,1,1,2,2,2,2]),array([0,1,2,3,0,1,2,3,0,1,2,3]))
排序，转置，区间截断
np.sort(A) 排序 ，默认升序 在最终维度上排序
np.transpose(A） #转置的两种方法，都是返回一个array
A.T#不同于A.flat A.T返回一个array
np.clip(A,5,9)
import numpy as np
A = np.arange(14,2, -1).reshape((3,4))
# array([[14, 13, 12, 11],
# [10, 9, 8, 7],
# [ 6, 5, 4, 3]])
print(np.sort(A))
# array([[11,12,13,14] 在最终的维度上进行排序
# [ 7, 8, 9,10]
# [ 3, 4, 5, 6]])
print(np.transpose(A))
print(A.T)
# array([[14,10, 6]
# [13, 9, 5]
# [12, 8, 4]
# [11, 7, 3]])
# array([[14,10, 6]
# [13, 9, 5]
# [12, 8, 4]
# [11, 7, 3]])
print(A)
# array([[14,13,12,11]
# [10, 9, 8, 7]
# [ 6, 5, 4, 3]])
print(np.clip(A,5,9))
# array([[ 9, 9, 9, 9]
# [ 9, 9, 8, 7]
# [ 6, 5, 5, 5]])
索引 切片等
A[3]
A[1][1]
A[1, 1:3]
A[:,2]
A[1,:]
与python中list操作方法和matlab中matlab操作方法类似 不再多作解释
合并
np.vstack() 属于一种上下合并，即对括号中的两个整体进行对应操作。
np.hstack() 数列的左右合并
np.newaxis()
**np.concatenate()**当你的合并操作需要针对多个矩阵或序列时，借助concatenate函数可能会让你使用起来比前述的函数更加方便：
np.concatenate((A,B,B,A),axis=0) 这个axis怎么理解呢？？
C = np.concatenate((A,B,B,A),axis=0)
print©
“”"
4个 axis等于0时 在第一个维度上发生变化 （3,1）合并成为（12,1） axis这个事发生变化的维度
axis参数很好的控制了矩阵的纵向或是横向打印，相比较vstack和hstack函数显得更加方便。
从shape这个角度可以更好地理解合并操作，对其他操作，关注自变量因变量的shape都是一个好的理解角度
import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
print(np.vstack((A,B))) # vertical stack
"""
[[1,1,1]
[2,2,2]]
"""
C = np.vstack((A,B))
print(A.shape,C.shape)
# (3,) (2,3)
D = np.hstack((A,B)) # horizontal stack
print(D)
# [1,1,1,2,2,2]
print(A.shape,D.shape)
# (3,) (6,)
print(A[np.newaxis,:]) #在最外层加一个维度
# [[1 1 1]]
print(A[np.newaxis,:].shape)
# (1,3)
print(A[:,np.newaxis]) #在最内层加一个维度
"""
[[1]
[1]
[1]]
"""
print(A[:,np.newaxis].shape)
# (3,1)
#此时我们便将具有3个元素的array转换为了1行3列以及3行1列的矩阵了。
#综合起来
import numpy as np
A = np.array([1,1,1])[:,np.newaxis]
B = np.array([2,2,2])[:,np.newaxis]
C = np.vstack((A,B)) # vertical stack
D = np.hstack((A,B)) # horizontal stack
print(D)
"""
[[1 2]
[1 2]
[1 2]]
"""
print(A.shape,D.shape)
# (3,1) (3,2)
#当你的合并操作需要针对多个矩阵或序列时，借助concatenate函数可能会让你使用起来比前述的函数更加方便：
C = np.concatenate((A,B,B,A),axis=0)
print(C)
"""
4个 axis等于0时 在第一个维度上发生变化 （3,1）合并成为（12,1）
array([[1],
[1],
[1],
[2],
[2],
[2],
[2],
[2],
[2],
[1],
[1],
[1]])
"""
D = np.concatenate((A,B,B,A),axis=1)
print(D)
"""
array([[1, 2, 2, 1],
[1, 2, 2, 1],
[1, 2, 2, 1]])
"""
分割
np.split(A, 2, axis=1) 纵向分割
np.split(A, 3, axis=0) 横向分割
np.array_split() 不等量分割
np.vsplit(A,3) 等同于np.split(A, 3, axis=0）
**np.hsplit(A,2)**等同于 np.split(A, 2, axis=1）
import numpy as np
A = np.arange(12).reshape((3, 4))
print(A)
"""
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
"""
print(np.split(A, 2, axis=1))
"""
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
"""
print(np.split(A, 3, axis=0))
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
print(np.split(A, 3, axis=1)) #无法等量分割
# ValueError: array split does not result in an equal division
print(np.array_split(A, 3, axis=1))
"""
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
"""
print(np.vsplit(A, 3)) #等于 print(np.split(A, 3, axis=0))
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
print(np.hsplit(A, 2)) #等于 print(np.split(A, 2, axis=1))
"""
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
"""
等号复制，浅拷贝，深拷贝 .
python的三种赋值方式
直接赋值
浅拷贝（copy）
深拷贝（deepcopy）
直接赋值，就是对象的引用。（相当于给原来的对象起个别名），比如有个人叫李大壮，外号叫小李，对象的引用就是类似，虽然换个名字，但是两个名字指的是同一个人。
浅拷贝
浅拷贝，拷贝的是父对象，不会拷贝到内部的子对象。（单从一个浅字就可以看出他拷贝的东西不深，可以理解为只拷贝一层）
深拷贝，包含对象里面的自对象的拷贝（可以理解为克隆，全拷贝过去但是两者没有任何关系了，各玩各的），所以原始对象的改变不会造成深拷贝里任何子元素的改变
array1 = array2().copy() 为深拷贝
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
