本节内容：
- 数组的创建
- 数组操作（获取数组属性，数组运算，数组复制，数组展开等等）
- 获取数组特定元素
1、创建数组
（1）常用的创建一维数组的方式
# 可以将任意类型的序列（列表、元组、字典、集合、字符串）传递给np.array()
a1 = np.array([1, 2, 3, 4]) # 传递列表
a2 = np.array((1, 2, 3, 4)) # 传递元组
a3 = np.array([1, 2, 3, 4], dtype=float) # 在创建时，指定数组元素的类型
a4 = a3.astype(str) # 也可以改变数组元素的类型
a5 = np.array([1, 2.0, 'a'], dtype=object) # 可以将类型设置成object，就能让数组接收多种类型的值
a6 = a5.tolist() # 可以将数组转化回list
print(a1, '\n') # [1 2 3 4]
print(a2, '\n') # [1 2 3 4]
print(a3) # [1. 2. 3. 4.]
print(a4) # ['1.0' '2.0' '3.0' '4.0']
print(a5) # [1 2.0 'a']
print(a6) # [1, 2.0, 'a']
（2）快速创建特定一维数组的几个方法
# 情况1
# 快速创建一个所有元素为0的数组,用np.zeros()
# 与此类似还有np.ones(),创建一个所有元素为1的数组
# 只有一个参数时可以写成：np.zeros(5)
# 打印结果：[0. 0. 0. 0. 0.]
my_new_array = np.zeros((5))
print(my_new_array)
# 情况2
# 创建一个随机数值的数组
# 默认是为每个元素分配0-1之间的随机值
# 同上述相同，只有一个参数时，可以写成np.random.random(5)
my_random_array = np.random.random((5))
print(my_random_array)
# 情况3
# 创建一个值范围为0到4的数组
c = np.arange(5)
print(c) # [0 1 2 3 4]
# np.arange()可以创建一个在定义的起始值和结束值之间具有特定序列的数组；3表示步长
c2 = np.arange(10, 35, 3)
print(c2) # [10 13 16 19 22 25 28 31 34]
# 情况4
# 在0到4之间创建4个元素的数组，这4个元素平均分布在0-4之间
d = np.linspace(0, 4, 4)
print(d) #[0. 1.33333333 2.66666667 4. ]
（3）创建多维数组
# 方式1
# 如下，为了创建一个二维数组，我们传递了一个列表的列表；
# 同理也可以传递一个元组的元组来创建一个二维数组；既有行又有列则为二维
a = np.array([[1.0, 2.0], [3.0, 4.0]])
print(a)
# 方式2
# 也可以通过reshape()方法将一维数组改造形状变成多维数组
# 这里是将一维数组变成4*5的二维数组
array = np.arange(20).reshape(4,5)
print(array)
2、数组的操作
（1）通过索引访问数组元素
# 对一维数组，a[i]形式访问数组
array1 = np.array([1, 2, 3, 4])
print(array1[0], array1[1], array1[2], array1[3]) # 1 2 3 4
# 对二维数组通过a[i][j]形式访问数组元素
array2 = array1.reshape(2, 2)
print(array2[0][0], array2[0][1], array2[1][0], array2[1][1]) # 1 2 3 4
# 如下形式也可以获取二维数组单个元素
print(array2[0, 0])
（2）获取数组的一些属性
array1 = np.array([1, 2, 3, 4])
array2 = array1.reshape(2, 2)
array3 = np.array(['a', 'b', 'c'])
# 1、打印array1对象的类型，<class 'numpy.ndarray'>
print(type(array1))
#2、 打印数组元素的数据类型
print(array1.dtype) # int32
print(array3.dtype) # <U1
# <表示字节顺序，小端（最小有效字节存储在最小地址中）
# U表示Unicode，数据类型
# 1表示元素位长，数据大小
# 3、打印数组元素个数
print(array1.size) # 4
print(array2.size) # 4
# 4、打印数组形状
print(array1.shape) # (4,)
# 也可以按方法的形式获取该属性
print(np.shape(array1)) # (4,)
print(array2.shape) # (2, 2)
# 可以获取shape返回的元组中的值;如下获取的就是array2数组有几行
print(array2.shape[0]) # 2
# 5、打印数组中的一个元素占几个字节;
# 因为在array1.shape数组元素是int32的，即32位整型；
# 而一个字节是8位，所以一个元素占32/8=4个字节
print(array1.itemsize) # 4
# 6、打印数组的维数;这个维数和shape元组中的元素个数一致
print(array1.ndim) # 1
#7、 打印数组要消耗多少内存（字节）；一般数组消耗的内存>=数组实际所占的内存
print(array1.nbytes) # 16
（3）数组的运算
array1 = np.array([[1, 2],
[3, 4]])
array2 = np.array([[5, 6],
[7, 8]])
# （1）可以发现数组的 + - * / 都是逐元素运算的
print(array1 + array2)
# [[ 6 8]
# [10 12]]
print(array1 - array2)
# [[-4 -4]
# [-4 -4]]
print(array1 * array2)
# [[ 5 12]
# [21 32]]
print(array1 / array2)
# [[0.2 0.33333333]
# [0.42857143 0.5 ]]
# （2）平方运算也是逐元素运算的
print(array1 ** 2)
# [[ 1 4]
# [ 9 16]]
# （3）>,<逻辑运算也是逐元素运算的；返回的是一个布尔型数组
print(array1 > array2)
# [[False False]
# [False False]]
# （4）array1.dot(array2)点积运算不是逐元素元素的，与矩阵乘法运算规则相同
print(array1.dot(array2))
# [[19 22]
# [43 50]]
# 对dot点积运算进一步探索；一维情况
x = np.array([1, 2, 3, 4])
y = np.array([5, 6])
# print(x.dot(y)) # 此时会报错,如下
# ValueError: shapes (4,) and (2,) not aligned: 4 (dim 0) != 2 (dim 0)
# 当两个一维数组的元素个数相同时，才能进行dot运算；1*5 + 2*6 + 3*7 + 4*8 = 70
z = np.array([5, 6, 7, 8])
print(x.dot(z)) # 70
# 对dot点积运算进一步探索；二维情况
p = np.array([[1, 2], [3, 4], [5, 6]])
q = np.array([2])
# print(p.dot(q)) # 报错如下;表明p的列数要和q的行数相等，点积才能运算
# ValueError: shapes (3,2) and (1,) not aligned: 2 (dim 1) != 1 (dim 0)
r = np.array([[1], [2]])
print(p.dot(r))
# [[ 5]
# [11]
# [17]]
# （5）特殊运算符
a = np.arange(10)
print(a.mean()) # 4.5
print(a.sum()) # 45
print(a.min()) # 0
print(a.max()) # 9
print(a.cumsum()) # [ 0 1 3 6 10 15 21 28 36 45]
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
# 逐列计算最小值
print(np.amin(a, axis=0)) # [1 2 3 4]
# 逐列计算最大值
print(np.amax(a, axis=0)) # [ 9 10 11 12]
# 逐行计算最小值
print(np.amin(a, axis=1)) # [1 5 9]
（4）数组的复制
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
# 浅复制；改变a2的同时，也改变了a
a2 = a
a2[0, 0] = 100
print(a)
# [[100 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
# 深复制；改变a3并没有改变a
a3 = a.copy()
a3[0, 1] = 101
print(a3)
# [[100 101 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
print(a)
# [[100 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
（5）flatten和ravel展开数组的区别
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
b1 = a.flatten()
b2 = a.ravel()
print(b1) # [ 1 2 3 4 5 6 7 8 9 10 11 12]
print(b2) # [ 1 2 3 4 5 6 7 8 9 10 11 12]
# 可以发现b1是浅复制(flatten())
b1[0] = 100
print(a)
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
# b2是深复制(a.ravel())
b2[0] = 999
print(a)
# [[999 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
（6）tile和repeat创建重复数组
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
# 重复a的整体,2次
b = np.tile(a, 2)
print(b)
# [[ 1 2 3 4 1 2 3 4]
# [ 5 6 7 8 5 6 7 8]
# [ 9 10 11 12 9 10 11 12]]
# 逐元素重复a,每个元素重复3次，行优先；可以发现repeat方法返回的结果是一维数组
c = np.repeat(a, 3)
print(c)
# [ 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8
# 9 9 9 10 10 10 11 11 11 12 12 12]
（7）随机数组的生成详述
# （1）生成2*2的随机数组；取值范围[0,1)
print(np.random.rand(2, 2))
# [[0.05351956 0.52744627]
# [0.65351703 0.45760785]]
# （2）打印均值为0方差为1的正态分布形成的2*2随机数组；
print(np.random.randn(2, 2))
# [[ 1.72616696e-01 -3.75028315e-01]
# [ 5.73511471e-01 -5.68613463e-04]]
# （3）打印2*2的随机数组，随机数取值范围在[0, 10),左闭右开
print(np.random.randint(0, 10, size=[2, 2]))
# [[8 3]
# [9 1]]
#（4） 打印随机数，取值范围[0,1)
print(np.random.random())
# 0.6703799424762051
# 打印随机数组，3个元素
print(np.random.random(3))
# [0.06488424 0.23714481 0.10028496]
# 打印2*1的随机数组
print(np.random.random(size=[2, 1]))
# [[0.64914024]
# [0.89535928]]
# （5）在给定的列表中选择随机元素组成数组
print(np.random.choice(['aaa', 'b', 'c', 'ddd'], size=3))
# ['b' 'b' 'aaa']
# 从给定的列表中选择10个项目，具有预定义的概率“p”;注意p中的概率加起来要等于1
print(np.random.choice(['a', 'e', 'i', 'o', 'u'], size=10, p=[0.3, 0.1, 0.1, 0.4, 0.1]))
# ['u' 'o' 'o' 'i' 'i' 'a' 'e' 'o' 'a' 'a']
# （6）如果要每次都重复同一组随机数，则需要设置种子或随机状态
# 方式1，创建随机状态;会发现运行两次打印出来的随机数组相同的
r1 = np.random.RandomState(100)
print(r1.rand(2, 2))
# [[0.54340494 0.27836939]
# [0.42451759 0.84477613]]
# 方式2，设置随机种子
np.random.seed(100)
print(np.random.rand(2, 1))
# [[0.54340494]
# [0.27836939]]
（8）unique方法
# np.unique()会返回无重复的数组元素；
# 将return_counts设置为True可以返回每个元素的计数;默认是False
a = np.array([1, 1, 2, 2, 2, 3, 4, 5, 6, 1])
u, c = np.unique(a, return_counts=True)
print(u, c) # [1 2 3 4 5 6] [3 3 1 1 1 1]
b = a.reshape(2, 5)
u, c = np.unique(b, return_counts=True)
print(u, c) # [1 2 3 4 5 6] [3 3 1 1 1 1]
3、获取数组元素的几种方法
（1）数组的切片操作—获取数组某块元素
a = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
# 获取单个数组元素可以直接通过索引方式得到；注意索引是从0开始
print(a[2, 4]) # 25
# 切片操作，就是获取数组某些部分的元素
# 打印数组第一行所有元素; 分号代表所有
print(a[0, :]) # [11 12 13 14 15]
# 打印数组第一列所有元素；
print(a[:, 0]) # [11 16 21 26 31]
# 打印第1,2,3列
print(a[:, 0:3])
# [[11 12 13]
# [16 17 18]
# [21 22 23]
# [26 27 28]
# [31 32 33]]
# 打印第1,2,4列
print(a[:, [0, 1, 3]])
# print(a[:, (0, 1, 3)]) # 元组也可以
# [[11 12 14]
# [16 17 19]
# [21 22 24]
# [26 27 29]
# [31 32 34]]
# 打印1,2,3行和1,2,4列
print(a[0:3, [0, 1, 3]])
# [[11 12 14]
# [16 17 19]
# [21 22 24]]
# 打印1,3,5行和1,3,5列; 即下标是0,2,4
print(a[::2, ::2])
# [[11 13 15]
# [21 23 25]
# [31 33 35]]
# 翻转行和翻转整个数组元素
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
print(a[::-1, ])
# [[ 9 10 11 12]
# [ 5 6 7 8]
# [ 1 2 3 4]]
print(a[::-1, ::-1])
# [[12 11 10 9]
# [ 8 7 6 5]
# [ 4 3 2 1]]
（2）花式索引—获取数组中的特定元素
# 一维数组下使用
a = np.arange(0, 100, 9)
print(a) # [ 0 9 18 27 36 45 54 63 72 81 90 99]
indices = [1, 5, -2]
print(a[indices]) # [ 9 45 90]
# 对二维数组同样适用；此时将嵌套的一维数组作为一个元素
a2 = a.reshape(3, 4)
print(a2)
# [[ 0 9 18 27]
# [36 45 54 63]
# [72 81 90 99]]
indices = [1, 2, -2]
print(a2[indices])
# [[36 45 54 63]
# [72 81 90 99]
# [36 45 54 63]]
indices = [1, -2]
print(a2[indices])
# [[36 45 54 63]
# [36 45 54 63]]
indices = [-1]
print(a2[indices])
# [[72 81 90 99]]
（3）布尔屏蔽—根据指定的条件获取数组中的元素
a = np.arange(0, 10)
print(a) # [0 1 2 3 4 5 6 7 8 9]
mask = a > 6
print(a[mask]) # [7 8 9]
（4）where() 函数是另外一个根据条件返回数组中的值的有效方法
a = np.arange(0, 100, 10)
print(a) # [ 0 10 20 30 40 50 60 70 80 90]
# 注意，np.where返回的是满足条件的元素下标
b = np.where(a < 50)
print(b) # (array([0, 1, 2, 3, 4], dtype=int64),)
# 可以通过数组的take方法获取满足条件的元素
print(a.take(b)) # [[ 0 10 20 30 40]]
# 获取返回的元组中的下标数组
c = np.where(a >= 50)[0]
print(c) # [5 6 7 8 9]
# np.where还有x,y两个参数
d = np.where(a >= 50, 'true', 'false')
print(d)
# ['false' 'false' 'false' 'false' 'false' 'true' 'true' 'true' 'true' 'true']
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
