在计算机中会把数学当中的矩阵叫做数组，在很多应用中的表格也就是通过矩阵表示的，所以numpy广泛用于机器学习，数据分析，和图像处理领域。 前言：在使用numpy创建数组之前必须先导入模块：import numpy as np 创建一维数组：arr1 = np.array([1, 2, 3]) 创建二维数组：arr4 = np.array([[1, 2], [3, 4]]) 查看数组维度：arr4.ndim 查看元素数量：arr4.size 查看元素形状：arr4.shape 查询元素的数据类型：arr4.dtype 查看对象的数据类：type(arr4) astype()生成新数组，原数组不变：arr5.astype(float) 创建指定维度和数据类型的空数组：np.empty([2, 3], dtype=int) 三个元素通过零填充：np.zeros(3) 三个元素通过1填充：np.ones(3) 创建指定维度和指定值填充的数组（3维通过8填充）：np.full([3, 3], 8) 创建指定步长的一维数组：np.arange(1, 12, 1) //array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) 7500-10000，6等分，结束点包含（等差数组）：np.linspace(7500, 10000, 6) 以2为底数，从2的1次方到2的10次方，5个元素：np.logspace(1, 10, 5, base=2) [0, 1)的一维数组，5个元素，小数：np.random.rand(5) [0, 1)的二维数组，2行5列，小数：np.random.rand(2, 5) [0, 10)的二维数组，2行3列，小数：np.random.uniform(0, 10, [2, 3]) 满足正态分布的一维数组，100个元素，均值为0，标准差为1：np.random.normal(0, 1, 100) [1, 3)的一维数组，10个元素，整数：np.random.randint(1, 3, 10) [0, 5)的二维数组，2行5列，整数：np.random.randint(0, 5, size=[2, 5]) 随机种子：作用是重复运行代码而数值不变，必须与随机函数在同一单元格 打乱数组：arr = np.array([1, 2, 3, 4, 5])；np.random.shuffle(arr) nan表示缺失值：arr = np.array([1, 2, np.nan, 4]) 查看缺失值：np.isnan(arr) 填充缺失值：arr[np.isnan(arr)] = 0 删除重复值： 通过列表创建数组： 通过字符串创建数组（这种方法是首先将字符串转为列表，然后把列表转为数组，直接将字符串转数组则数组中只有一个元素）： 通过可迭代对象创建数组： 以指定值填充： 数组四则运算：+、-、*、/、**、这些运算都是两个形状相同的数组进行的对应元素之间的运算 数组取整：// 取余/取模：% 求相反数：-数组名 求倒数：1/数组名 比较运算：>=、==、<=、！=、这些运算都是两个形状相同的数组进行的对应元素之间的运算 标量运算：数组中每个元素和数值之间的运算（数组名 运算符号 数值） 集合运算：求a和b的交集（np.intersect1d(a, b)）、求a和b元素的并集（np.union1d(a, b)）、a数组的每个元素是否包含在b数组内（np.in1d(a, b)）这里的1d代表1维、差集，a数组减去b数组的元素（np.setdiff1d(a, b)）；不要求数组和b数组形状一样，集合运算只是两个数组元素的集合之间的运算。 前言：列表也能切片，但是列表的计算性能没有数组好。 切片操作：arr[start:stop:step] arr = np. array( [ 1 , 2 , 3 , 4 ] )
arr[ 0 : 2 ]
arr = np. arange( 10 )
arr[ : : - 1 ]
arr = np. array(
[ [ 0 , 1 , 2 , 3 ] ,
[ 4 , 5 , 6 , 7 ] ,
[ 8 , 9 , 10 , 11 ] ] )
lst = [ [ 0 , 1 , 2 , 3 ] , [ 4 , 5 , 6 , 7 ] , [ 8 , 9 , 10 , 11 ] ]
arr[ 1 ]
lst[ 1 ] [ 2 ]
arr[ : 2 , 1 : ]
arr1 = np. arange( 6 )
arr1. reshape( 2 , 3 )
arr1. reshape( - 1 , 1 )
arr2 = np. array(
[ [ 0 , 1 , 2 ] ,
[ 3 , 4 , 5 ] ] )
arr10 = arr2. reshape( 3 , 2 )
arr2. reshape( - 1 )
重塑前后的元素个数可以不一致 重塑后会修改原数组
重塑后比原尺寸小：自动截断 重塑后比原尺寸大：以0填充 arr6 = np. arange( 12 ) . reshape( 3 , 4 )
'''
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
'''
arr6. T
'''
array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]])
'''
arr6. transpose( )
'''
array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]])
'''
n1 = np. array(
[ [ 1 , 2 ] ,
[ 3 , 4 ] ,
[ 5 , 6 ] ] )
n2 = np. array(
[ [ 10 , 20 ] ,
[ 30 , 40 ] ,
[ 50 , 60 ] ] )
np. hstack( ( n1, n2) )
np. column_stack( ( n1, n2) )
'''
array([[ 1, 2, 10, 20],
[ 3, 4, 30, 40],
[ 5, 6, 50, 60]])
'''
np. vstack( ( n1, n2) )
np. row_stack( ( n1, n2) )
'''
array([[ 1, 2],
[ 3, 4],
[ 5, 6],
[10, 20],
[30, 40],
[50, 60]])
'''
n3 = np. arange( 24 ) . reshape( 6 , 4 )
'''
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])
'''
np. hsplit( n3, 2 )
'''
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13],
[16, 17],
[20, 21]]),
array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15],
[18, 19],
[22, 23]])]
'''
np. vsplit( n3, 2 )
'''
[array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]),
array([[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])]
'''
aa = np. arange( 6 ) . reshape( 2 , 3 )
'''
array([[0, 1, 2],
[3, 4, 5]])
'''
np. append( aa, [ [ 6 , 7 , 8 ] ] , axis= 0 )
'''
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
'''
np. append( aa, [ [ 10 ] , [ 20 ] ] , axis= 1 )
'''
array([[ 0, 1, 2, 10],
[ 3, 4, 5, 20]])
'''
ad = np. arange( 6 ) . reshape( 2 , 3 )
'''
array([[0, 1, 2],
[3, 4, 5]])
'''
np. delete( ad, 1 , axis= 0 )
'''
array([[0, 1, 2]])
'''
np. delete( ad, 0 , axis= 1 )
'''
array([[1, 2],
[4, 5]])
'''
np. delete( ad, [ 0 , 1 ] , axis= 1 )
'''
array([[2],
[5]])
'''
a1 = np. arange( 6 ) . reshape( 2 , 3 )
a1[ 1 ] = [ 0 , 0 , 0 ]
a1[ : , 1 ] = [ 0 , 0 ]
a1[ 0 : , 1 ] = 2
np. where( a1 > 1 , 6 , 9 )
'''
array([[9, 9, 6],
[6, 6, 6]])
'''
a1[ np. where( a1 > 1 ) ]
a = np. arange( 10 )
b = a
b is a
a[ 0 ] = 8
b
a = np. arange( 10 )
c = a. view( )
c is a
a[ 0 ] = 8
a = np. arange( 10 )
d = a. copy( )
d is a
a[ 0 ] = 8
d
import copy
d = copy. deepcopy( a)
在Python中，复制一个变量有两种方式：深拷贝和浅拷贝。当使用浅拷贝（shallow copy）时，创建的新对象与原始对象共享内存，也就是说，如果修改其中一个对象，另一个对象也会改变。而使用深拷贝（deep copy）时，完全复制一份独立的对象，包含了对象及其所有子对象的完整拷贝，修改其中任意一个对象，都不会对其他对象产生影响。数组复制的浅拷贝虽然修改一个对象，另一个对象不会发生改变，原因不是复制了一份独立的对象，而是在独立对象之上做了封装。如下：
