ʚʕ̯•͡˔•̯᷅ʔɞ
🍹欢迎各路大佬来到小啾主页指点☀️
✨博客主页:云雀编程小窝 🌹꧔ꦿ
🌹꧔ꦿ支持我:点赞 + 关注 + 收藏✨
🌹꧔ꦿ欢迎大家在评论区交流分享!
numpy导包 和 查看版本 命令
import numpy as np
print(np.version)
==============================================================================
array()语法
array(object,dtype=None, copy=True, order=‘K’, subok=False, ndmin=0)
-
odject:任何具有数组借口方法的对象。通常也可以理解为是可迭代对象。
-
dtype:数据类型。
-
copy:布尔类型值,是否复制,默认为True。设为true可以避免对数组数据有修改操作时影响到原数组。具体见下文**“数组的复制”** 部分。
-
order:元素在内存中出现的顺序,可以是"K"、“A”、“C”、“F"四个字符。
默认为“K”,表示元素在内存中出现的顺序。
“C”表示按行排列,“F”表示按列排列。
如果object是一个数组,则还可以是"A”,表示原顺序。
-
subok:布尔类型。默认为False,表示返回的数组默认为基类数组。如果为True则将传递子类。
-
ndmin:生成数组的 最小维度。(最小,意味着可以大于这个数字,当不足这个数字时,补充到这个数字。)
1.1.1 通过列表创建
a1 = np.array([1, 2, 3, 4, 5])
print(a1,a1.shape)
a2 = np.array([1, 2, 3, 4, 5], ndmin=2)
print(a2, a2.shape)
a3 = np.array([1, 2, 3, 4, 5], ndmin=3)
print(a3, a3.shape)
如图,分别创建出了一维、二维、三维数组,并打印出了其shape。
1.1.2 通过元组创建简单
a2 = np.array((1., 2., 3, 4., 5.))
print(a2)
效果差不多同上,这个没啥特别的。
1.1.3 通过字符串创建
a3 = np.array(‘123’)
print(a3)
print(type(a3))
如图,创建出的是一个长度为1的一维数组。
而不是将字符串分割长度为3的。
1.1.5 通过数组创建
1.1.5.1 创建
n1 = np.array([1, 2, 3])
n2 = np.array(n1)
print(n2)
print(“=======================================”)
n3 = np.array([[1, 2, 3], [4, 5, 6]])
n4 = np.array(n3)
print(n4)
如图分别创建了一个一维数组和一个二维数组。
1.1.5.2 数组的复制
当我们需要修改数组又不想影响到目标数组时,通常可以通过“用数组创建数组”,进而实现对目标数组的复制操作。
- 选择不复制,把copy参数设置为False时:
n1 = np.array([1, 2, 3])
n2 = np.array(n1)
n1 = np.array([1, 2, 3])
n2 = np.array(n1, copy=False)
print(“n1:”, n1)
print(“n2:”, n2)
n2[0] =100
print(“修改n2的第一个数据*”)
print(“n1:”, n1)
print(“n2:”, n2)
如图,n2和n1共用存储。当修改n2时,n1也被修改了。
- 选择复制时,即copy=True,也是copy的默认值。
n3 = np.array([[1, 2, 3], [4, 5, 6]])
n4 = np.array(n3)
print(“n3:”, n3)
print(“n4:”, n4)
n4[0][1] =100
print(“修改n4(0,1)位置的数据*”)
print(“n3:”, n3)
print(“n4:”, n4)
如图,n3和n4没有共用存储,所以当n4被修改时,不影响n3。
1.1.4 通过range创建
将range对象转化为列表对象即可传入。
a1 = np.array(list(range(10)))
print(a1)
(结果数据类型是整数型)
也可以直接传入一个range()对象
print(np.array(range(10)))
arrange是numpy对range优化过后的方法,常用来创建数组。而通常不再采用上边的range()方法。
此处了解即可。
语法
arange([start],stop,[,step],dtype=None)
取值方式为取左不取右,[start, stop),不包含终止值stop。
使用示例
a1 = np.arange(0, 10, 2)
print(a1)
(此时结果数据类型是整数型)
a2 = np.arange(0, 10, 0.2)
print(a2)
(此时结果数据类型是浮点类型)
使用linspace()方法,可以快捷地通过指定范围和数据个数的形式,来创建出数组(等差数列形式)。
语法
linspace(start, stop, num=50, end_point=True, restep=False, dtype=None)
-
不同于arange()方法,linspace()方法传入参数表示的区间是从起始值到结束值的闭区间,而arange()传入的参数表示的区间是左闭右开区间。
-
num 表示生成数组的数字个数。
-
endpoint 布尔类型,默认为True,表示包含stop。否则可以不包含。
-
restep 布尔类型,默认为True,表示生成的数组显示间距。否则不显示。
创建两个数组作为示例:
n1 = np.linspace(100, 200, 11)
print(n1)
print(“======================================================================”)
n2 = np.linspace(10, 20, 101)
print(n2)
可以看出无论结果是否是整数,都默认为是浮点型。
使用logspace()方法,可以创建出等比数列形式的数组。
语法
logspace(start, stop, num=50, end_point=True, base=10.0, dtype=None)
-
start 序列起始值的指数 ,序列的起始值为 b a s e s t a r t \displaystyle base^{start} basestart
-
stop 序列结束值的指数,序列的结束值为 b a s e s t o p \displaystyle base^{stop} basestop
-
base表示对数log的底数。值得注意的是,base未必是等比数列的公比。
通过下例具体感受其用法:
n1 = np.logspace(0, 10, 6, base=2, dtype=‘int’)
print(n1)
print(“======================================================================”)
n2 = np.logspace(0, 10, 11, base=2, dtype=‘int’)
print(n2)
print(“======================================================================”)
n3 = np.logspace(0, 10, 21, base=4, dtype=‘int’)
print(n3)
如图,n1的公比为4,n2的公比为2,n3的公比为2。
empty()方法常用于创建指定维度和数据类型未初始化 的数组。
n1 = np.empty([2, 3])
print(n1)
print(“======================================================================”)
n2 = np.empty([2, 3], dtype=int)
print(n2)
其中,数组n1的元素为随机值。
a1 = np.ones(10)
print(a1)
(结果数据类型默认是浮点类型)
a1 = np.zeros(10)
print(a1)
(结果数据类型默认是浮点类型)
shape为(3,4),以整数类型数字 9 填充。
n = np.full((3, 4), 9)
print(n)
n1 = np.eye(9)
print(n1)
print(“======================================================================”)
n2 = np.eye(9, dtype=int)
print(n2)
diag()方法用于创建对角线矩阵形式的数组,且diag()方法没有dtype参数。
a = [1, 2, 3, 4, 5]
print(np.diag(a))
①rand()方法
语法
np.random.rand(d0,d1,d2,d3,d4,…,dn)
randn()函数可以用于生成随机数或者随即数组。当不传入参数时,生成一个随机数。当传入参数时,则生成指定shape的随即数组。
- 数据的范围为[0, 1)
指定shape时不要求元组形式。参数个数不限制。这一点是区别于np.random.random()方法。
print(“生成一个随机数”)
n1 = np.random.rand()
print(n1)
print(type(n1))
print(“==============================”)
print(“生成一个一维随机数”)
n2 = np.random.rand(3)
print(n2)
print(type(n2))
print(“==============================”)
print(“生成一个二维随机数”)
n3 = np.random.rand(2, 3)
print(n3)
print(type(n3))
② random()方法
random()的用法及作用于rand相似,只是需要传入的参数是一个元组。
生成数据的范围也是[0, 1)
print(“生成一个随机数”)
print(np.random.random())
print(“==============================”)
print(“生成一个一维随机数”)
print(np.random.random(5))
print(“==============================”)
print(“生成一个二维随机数”)
print(np.random.random((3, 5)))
③randint()方法
randint()方法可以用于生成有一定范围的随机整数。
- 语法
np.random.randint(low, high=None, size=None)
-
low 起始值 整数
-
high 终止值 整数 应满足 low < high 否则会报错
-
[low, high) 左闭右开,可取左,不可取右。
-
size 整数或描述shape的元组。整数表示一维。
print(np.random.randint(0, 100, 5))
print(“==============================”)
print(np.random.randint(0, 100, (4, 4)))
④randn()方法
通过randn()方法可以得到满足标准正态分布的数组
X X X~ ( 0 , 1 ) (0, 1) (0,1)
语法
randn(d0,d1,d2,d3,…,dn)
参数形式同rand(),不是元组。表示shape。
print(“生成一个标准正态分布下的数字,这样没啥意义”)
print(np.random.randn())
print(“=====================================”)
print(“生成一个一维数组”)
print(np.random.randn(8))
print(“=====================================”)
print(“生成一个二维数组”)
print(np.random.randn(2, 3))
print(“=====================================”)
print(“生成一个三维数组”)
print(np.random.randn(2, 3, 4))
数组的数据越多,才越能体现其分布特点。
⑤normal()方法
normal()方法也可以用于生成正态分布数组,且不限于标准正态分布,可以自定义分布参数。
语法
np.random.normal(loc=0.0, scale=1.0, size=None)
-
loc 均值
-
scale 标准差
-
size,即shape,或维度。要求是一个元组或一个数字。
默认生成数据满足标准正态分布。
print(“生成一个标准正态分布下的数字,这样没啥意义”)
print(np.random.normal())
print(“=====================================”)
print(“生成一个一维数组,均值为5标准差为10,元素个数为10”)
print(np.random.normal(5, 10, 10))
print(“=====================================”)
print(“生成一个二维数组,均值为4,标准差为5,shape为(4, 5)”)
print(np.random.normal(4, 5, (4, 5)))
print(“=====================================”)
print(“生成一个三维数组,均值为2,标准差为4,shape为(2, 3, 4)”)
print(np.random.normal(2, 4, (2, 3, 4)))
⑥随机数种子 seed()
有的情况下,为了保证得到一致的随机数,需要用到随机数种子
即给np.random.seed()传入一个大于等于0的整数
不管是在同一台电脑上多次允许,还是在不同的电脑上执行程序,只要随机数种子设置相同,则就可以保证得到相同的随机数。
写法示例:
np.random.seed(1)
print(np.random.randint(100, 200, (4, 4)))
⑦随机排序
-
对数组随机排序可以使用shuffle() 和 permutation() 两个方法。
-
区别在于shuffle()方法直接修改的是原数组,而permutation()不影响原数组。
-
两个方法均只有一个参数,为一个数组。
-
对数组对象中1数据随机排序
-
随机排序时,仅对数组最外层的维度排序,即axis=0。就是说,以shape为(5,6,7,8,9)的数组为例,随机排序打乱的是元素个数为“5”这个维度的5个对象。五个对象自身内部结构不会被改变。
-
此外,随机数种子固定的时候,随机排序的效果也是固定的。
代码示例 shuffle() :
np.random.seed(1)
n = np.random.randint(100, 200, (4, 4))
print(n)
print(“==随机排序=”)
np.random.shuffle(n)
print(n)
代码示例 permutation() :
np.random.seed(2)
n = np.random.randint(100, 200, (4, 4))
print(n)
print(“==随机排序=”)
print(np.random.permutation(n))
print(“原数组不改变”)
print(n)
⑧随机抽取 choice()方法
语法
numpy.random.choice(a, size=None, replace=True, p=None)
- a 一个列表 或者 一个数组,表示要从中抽样的对象。
也可以是一个正整数,是正整数的话则表示从[0, a)的整数中随机抽取 。
-
size 即shape,元组。也可以是一个数字,表示一维数组。
-
replace 是否有放回。默认为True是有放回的抽取。
-
p 抽取到的概率。默认为None,表示所有元素抽取到的概率相等。也可以是一个数组,是数组的话,该数组的shape应与参数a数组的shape相同。该数组中的每个元素对应着数组a中相同位置的每个元素被抽取到的概率。
np.random.seed(3)
print(“从[0,100)中随机抽取一个整数”)
print(np.random.choice(100, 5))
data = [11, 22, 33, 44, 55, 66, 77, 88, 99, 100]
print(“从data中随机抽取一个数字”)
print(np.random.choice(data))
print(“=====================================”)
print(“随机抽取3个数字,构成三个元素的一维数组”)
print(np.random.choice(data, 3))
print(“=====================================”)
print(“随机抽取数组构成一个二维数组”)
print(np.random.choice(data, (2, 3)))
print(“随机抽取数组构成一个二维数组,无放回的抽取”)
print(np.random.choice(data, (2, 3), replace=False))
①asarray()方法
asarray()方法与array()函数类似,差别不大。这里了解即可。
asarray(a,dtype=None,order=None)
- a可以是数组,也可以是列表、元组等对象。而且是列表元组等时,可以支持一直套娃,套多少层,创建出来的维度就有多高。
a = np.asarray([1, 2, 3])
print(a)
print(“=================================”)
b = np.asarray([[1, 2, 3], [4, 5, 6]])
print(b)
print(“=================================”)
c = np.asarray(((1, 2), (3, 4)))
print©
print(“=================================”)
d = np.asarray((((1, 2), (3, 4)), ((5, 6), (7, 8))))
print(d)
print(“=================================”)
e = np.asarray(a)
print(e)
②formbuffer()方法
用formbuffer()方法创建数组,该方法的特点及优势在于,该方法接收字节流形式的参数。
语法
np.frombuffer(buffer, dtype=None, count=-1, offset=0)
-
buffer指实现了__buffer__方法的对象。当buffer参数值为字符串时,因为python3默认字符串是Unicode类型,所以要转换成Byte string类型,需要在原字符串前加上b。
-
dtype 即数据类型,默认为浮点型。
-
count 读取数据的数量,默认值-1表示读取所有数据。
-
offset 读取的起始位置,默认从0位置开始。
通过以下一系列示例,快速理解其用法。
n1 = np.frombuffer(b"12345678987654321", dtype=‘S1’)
print(n1)
print(“=================================”)
n2 = np.frombuffer(b"1234567887654321", dtype=‘S2’)
print(n2)
print(“=================================”)
n3 = np.frombuffer(b"1234567887654321", dtype=‘S4’)
print(n3)
print(“=================================”)
n4 = np.frombuffer(b"abcdefghijklmnop", dtype=‘S4’)
print(n4)
print(“=================================”)
n5 = np.frombuffer(b"abcdefghijklmnop") # 转浮点型了
print(n5)
print(n5.dtype)
③fromiter()方法
fromiter()方法可用于从可迭代对象(iterable) 中创建数组。
创建一个生成器
a1 = (x * 3 for x in range(6))
print(a1)
通过生成器这个可迭代对象创建数组
a2 = np.fromiter(a1, dtype=‘int’)
print(a2)
数据较多时这种方法比较高效。可以实现快速将生成器中的大量数据导入数组中。
a3 = np.fromiter((2, 5, 6, 8, 5, 2), dtype=‘int’)
print(a3)
a4 = np.fromiter([2, 5, 6, 8, 5, 2], dtype=‘int’)
print(a4)
- 需要注意的一点是,使用fromiter()方法时,传入的可迭代对象不能是 有嵌套其他可迭代对象 的可迭代对象。fromiter()方法不支持套娃。
④empty_like()方法
创建一个与给定数组相同shape的未初始化的数组
语法
empty_like(prototype, dtype=None, order=None, subok=None, shape=None)
n = np.arange(1, 7).reshape(2, 3)
print(n)
print(“===============================”)
a = np.empty_like(n)
print(a)
⑤zeros_like()方法
创建一个与给定数组相同shape的全零数组
语法
zeros_like(a, dtype=None, order=‘K’, subok=True, shape=None)
n = np.arange(1, 7).reshape(2, 3)
print(n)
print(“===============================”)
a = np.zeros_like(n)
print(a)
⑥ones_like()方法
创建一个与给定数组相同shape的 全一数组
语法
ones_like(a, dtype=None, order=‘K’, subok=True, shape=None)
n = np.arange(1, 7).reshape(2, 3)
print(n)
print(“===============================”)
a = np.ones_like(n)
print(a)
⑦fulls_like()方法
创建一个与给定数组相同shape的指定值填充的数组
语法
full_like(a, fill_value, dtype=None, order=‘K’, subok=True, shape=None)
n = np.arange(1, 7).reshape(2, 3)
print(n)
print(“===============================”)
a = np.full_like(n, 100)
print(a)
======================================================================================
通过上述方法创建数组时,上边的示例中并未指定数据类型。
通过上边的示例可以看到,不指定数据类型创建数组时,如果不是根据一个传入的 具体的有数组接口方法对象来创建,则创建出的数组的数值类型默认为浮点型。其中,除了使用arange()且各个数字刚好是整数时,是个例外,得到的数组的数据类型为整数型(回顾一下上文的arange即可理解,因为arange方法与array()里边放一个 list(range(n)) 是类似的。)
关于创建数组时数据类型默认具体是怎么样的(int32, int64, float32, float64…),我现在所了解的资源中说法有很多,有的说是跟个人的操作系统有关,有的认为是保存对象所需的最小类型。目前我不清楚哪一种是对的,不过可以确定的是,我们最好在创建数组的时候,我们通常不采用默认值,最好自己指定,这样就不会产生因为数据类型带来的问题了。(如有观点或其他答案欢迎在评论区补充。)
对类型的位数有需求时,不建议使用常规的时int,float,unit指定,而后边不跟数字,也不建议使用默认值。最好自己手动指定到位。
常用的基本数据类型如下表所示:
| 类型 | 类型代码/简写 | 描述 |
| — | — | — |
| int8,uint8 | i1,u1 | 有符号和无符号的8数位整数(-128127)(0255) |
| int16,uint16 | i2,u2 | 有符号和无符号的16数位整数(-3276832767)(065535) |
| int32,uint32 | i4,u4 | 有符号和无符号的32数位整数(-21474836482147483647)(04294967295) |
| int64,uint64 | i8,u8 | 有符号和无符号的64数位整数(-92233720368547758089223372036854775807)(018446744073709551615) |
| float16 | f2 | 半精度浮点数:1个符号位,5位指数,10位尾数 |
| float32 | f4 | 标准单精度浮点数:1个符号位,8位指数,23位尾数 |
| float64 | f8 | 标准双精度浮点数:1个符号位,11位指数,52位尾数 |
| bool | ------------ | 存储一个字节的布尔值,存储True或False。(也可写为bool_) |
| complex64 | ------------ | 复数,由两个32位浮点表示(实部和虚部) |
| complex128 | 简写:complex_ | 复数,由两个64位浮点表示(实部和虚部) |
| datatime64 | ------------ | 日期和事件类型 |
| timedelta | ------------ | 两个时间类型的间隔 |
| string_ | S | ASCII字符串类型(即字节类型),eg:‘S10’ |
| unicode_ | U | Unicode类型(python3的默认字符串是Unicode类型),eg:‘U10’ |
其中unit16表示16位无符号整数,unit32表示32位无符号整数。
其中,复数不能转化为其他数值类型。
几种变换,简单了解。
print(np.int32(12.56), type(np.int32(12.56)))
print(np.float64(13), type(np.float64(13)))
print(np.complex128(1+2j), type(np.complex(1+2j)))
print(np.unicode(‘20’), type(np.unicode(‘20’)))
根据上表,创建数组时,指定数据类型,可以使用类型的全名,也可以使用类型代码。
使用array(),zeros(),ones(),empty(),arange(),linspace(),logspace(),eye()等方法创建数组时都可以通过dtype参数指定数据类型。dtype默认为None。
下边通过一些调用示例,来完成这个部分的学习。
2.3.1 整数与浮点数
a1 = np.array([1.23, 2.34, 3.45, 4.56], dtype=int)
print(a1)
print(a1.dtype)
a2 = np.arange(0, 10, 2, dtype=‘int’)
print(a2)
print(a2.dtype)
(不同:a1中传入的是关键字int,a2中传入的是字符串int。达到的效果一样。)
a3 = np.linspace(100, 200, 11, dtype=‘int64’)
print(a3)
print(a3.dtype)
a4 = np.logspace(0, 10, 11, base=2, dtype=‘int32’)
print(a4)
print(a4.dtype)
a5 = np.empty([2, 3], dtype=‘i8’)
print(a5)
print(a5.dtype)
a6 = np.ones(10, dtype=‘i4’)
print(a6)
print(a6.dtype)
a7 = np.zeros(10, dtype=‘f4’)
print(a7)
print(a7.dtype)
![在这里插入图片描述]( )
print(a8)
print(a8.dtype)
2.3.2 字节类型
a9 = np.full((3, 4), ‘99.0’, dtype=‘S’)
print(a9)
print(a9.dtype)
a10 = np.full((3, 4), ‘99.0’, dtype=‘S2’)
print(a10)
print(a10.dtype)
a11 = np.full((3, 4), ‘aaaaaaaaaaa’, dtype=‘|S5’)
print(a11)
print(a11.dtype)
如图,数据类型分别是,一个字节,二个字节,五个字节。
直接指定为"S"表示S1,也可以在S前加一个竖杠"|’ 符号,这个符号可有可无。
如果传入汉字,则无法转化为字节,则发生报错。
a11 = np.full((3, 4), ‘侯小啾’, dtype=‘S5’)
print(a11)
print(a11.dtype)
报错。
2.3.3 字符串类型
python3的默认字符串是Unicode类型。
a12 = np.full((3, 4), ‘99.0’)
print(a12)
print(a12.dtype)
a13 = np.full((3, 4), 99.0, dtype=‘U1’)
print(a13)
print(a13.dtype)
a14 = np.full((3, 4), 99.0, dtype=‘<U3’)
print(a14)
print(a14.dtype)
a15 = np.full((3, 4), 99.0, dtype=‘U9’)
print(a15)
print(a15.dtype)
不指定时,则为数据中心字符串的长度的字符串类型,这里为U4,也可以写为<U4。
字符长度长短不一时,数组的数据类型由数据中最长的字符串所决定。
a16 = np.array([[‘a’, ‘aa’, ‘aaa’], [‘aaaa’, ‘aaaaa’, ‘aaaaaa’]])
print(a16)
print(a16.dtype)
支持汉字,这里一个汉字记为一个长度。
a17 = np.array([‘侯小啾’, ‘支持小啾’, ‘关注他!’, ‘给他四连!’])
print(a17)
print(a17.dtype)
最长的字符是“给他四连!”,长度为5,所以数组的数据类型为"<U5"
====================================================================================
为了方便快速查看数组的属性,特定义以下函数,务必带走方便在学习及编程过程中随时调用。
def print_array(name, a):
print(name)
print(a)
print('rank = ', a.ndim) # 秩,即有几个轴,几维
print('shape = ', a.shape) # 形状
print('size = ', a.size) # 数据个数
print('data type = ', a.dtype) # 数据类型
print('element size = ', a.itemsize) # 每个元素占的字节数
print('data location = ', a.data) # 数据存储的位置
print()
n = np.array([[1, 2, 3], [4, 5, 6]])
print_array(“数组n:”, n)
3.2.1 reshape()与resize()
对数据的结果进行重塑可以使用reshape() 或 resize()方法。
这两种方法的区别在于使用reshape()不修改原数组,而resize()是对原数组进行修改。
- 关于reshape
新建一个一维数组
a1 = np.arange(30)
print(a1)
print(“=====================”)
一维变二维
a2 = a1.reshape((5, 6))
print(a2)
print(“=====================”)
一维变三维
a3 = a1.reshape((2, 3, 5))
print(a3)
print(“=====================”)
三维变一维
a4 = a3.reshape((30,))
print(a4)
print(“=====================”)
三维变二维
a5 = a3.reshape((5, 6))
print(a5)
- 关于resize()
a1 = np.arange(30)
print(a1)
print(“=====================”)
一维变二维
a1.resize((5, 6))
print(a1)
如图,用法resize()用法与reshape()一致,只是resize()直接修改了原数组a1。具体根据实践过程合理选择使用。
- 修改shape时,shape的每个数字相乘必须等于数组元素的个数,否则会报错。
3.2.2flatten() 与 ravel()
使用flatten()和ravel()方法,可以直接将数组从多维变为一维。
a6 = a3.flatten()
print(a6)
a7 = a3.ravel()
print(a7)
fallen()与ravel()的区别在于,fallen()得到的新数组与原数组不共享存储,即为copy过来的,所以修改a3.fallen()时不会影响a3。而ravel()得到的新数组与原数组共享存储,修改a3.ravel()时,a3会被同步修改。
n1 = np.arange(12).reshape(3, 4)
print(n1)
print(n1.shape)
print(“=====================”)
n2 = n1.T
print(n2)
print(n2.shape)
3.4.1 索引
①一维数组为例
首先创建一个一维数组
a1 = np.arange(10)
print(a1)
取出该数组第一个数值 和 最后一个数值
print(a1[0])
print(a1[-1])
②二维数组为例
创建一个二维数组
a2 = np.arange(12).reshape(3, 4)
print(a2)
取出第一“行” 和 最后一“行”(这里说“行”只能用于二维数组,在更高维的数组是不准确的,不能说是行,而需要理解为是 在其所有维度中,序号为第一层的维度,或者说是最外层的维度 处的坐标。计数从0计起。):
print(a2[0])
print(a2[-1])
- 取出指定位置处的元素
print(a2[1][2])
print(a2[1, 2])
③三维数组为例(高维)
(关于三维及其以上的高维数组,使用为描述趋于)
a3 = np.arange(30).reshape((2, 3, 5))
print(a3)
取出其最外层维度下的第一个对象:
print(a3[0])
再剥一层:
print(a3[0][1])
再剥一层:
print(a3[0][1][2])
一个括号的写法:
print(a3[0, 1, 2])
**重点,易混淆点!如果想要取出多个值(不用切片),则可以在括号内嵌套括号。
如下列代码,值得注意的是,这样取出的不是四个值,而是两个值。
不是在第二次取出1,2后,再分别在1,2两个行中取出2和3。而是取出的是(0,1,2)和(0,2,3)。**
print(a3[0, [1, 2], [2, 3]])
(这一点在学习了DataFrame的操作后后如果理解得不够透彻则容易弄混淆。)
3.4.2 切片
①一维数组为例
首先创建一个一维数组
a1 = np.arange(10)
print(a1)
print(a1[2:5])
- 还是一如既往的左闭右开。
②二维数组为例
创建一个二维数组
a2 = np.arange(30).reshape(5, 6)
print(a2)
print(a2[2:4, 1:3])
一种不太常用的用法可以了解一下,
start:stop 后边可以再接一个冒号和数值,该数值表示step,步长。
步长通常为正。
如果想要倒序取值,则需要满足start>stop,然后把步长设置为负值。(只把步长设为负值的话会得到一个空数组。)
a1 = np.arange(10)
print(a1[2:7])
print(a1[2:9:2])
print(a1[9:2:-1])
print(a1[9:2:-2])
③三维数组为例(高维)
a3 = np.arange(120).reshape(4, 5, 6)
print(a3)
print(a3[0:2, 1:3, 2:5])
3.4.3 布尔索引
n1 = np.arange(30).reshape(5, 6)
print(n1)
print(n1 > 10)
print(“======================================”)
print((n1 > 10) & (n1 < 20))
print(“======================================”)
print(n1[n1 > 10])
print(“======================================”)
print(n1[(n1 > 10) & (n1 < 20)])
print(“======================================”)
print(n1[(n1 < 10) | (n1 > 20)])
使用布尔索引,不管原数组是几维,取出的数据存放在一个一维数组中。
==============================================================================
准备两个数组的数据,两个数组的shape必须相同,才能进行加减乘除运算
n1 = np.arange(1, 7).reshape(2, 3)
n2 = np.arange(7, 13).reshape(2, 3)
n3 = np.arange(4, 7).reshape(1, 3)
n4 = np.arange(5, 7).reshape(2, 1)
print(n1)
print(“-------------------------------”)
print(n2)
print(“-------------------------------”)
print(n3)
print(“-------------------------------”)
print(n4)
数据具有广播机制
其规则为:如果两个数组的后缘维度(trailing dimension,即从末尾开始算起的维度)的轴长度相符或其中一方的长度为1,则认为他们是广播兼容的。广播会在缺失和(或)长度为1的维度上进行。
这里的后缘维度,即指的是二维数组中的行和列这两个维度,在更高维数组中则指0轴和1轴的两个维度。在进行加减乘除幂等运算时,广播机制将发挥作用,
这一点可以分为以下几种情况来理解:
- 两个shape相同的数组之间进行运算,
则广播机制不启用,数组中相同位置的数据一一对应进行运算。
- 两个shape不同的数组a、b之间运算,如果数组b的0轴或1轴的长度为1,且长度为1的轴经过一定的倍数扩展后可以满足两个数组的shape相同,则广播机制启用,该长度为1的维度扩展到与数组a 在该维度的长度相等再进行运算。
具体可以分为以下几种情况:
例如,
一个4行5列的数组,可以与与一个1行5列的数组运算,运算时将次1行复制为4行;
也可以与一个5行1列的数组进行运算,运算时将该1列复制为5列。
但是不可以与一个4行2列、2行5列的数组进行运算。
也不可以与一个3行1列的数组,或者一个1行6列的数组进行运算。
再例如,一个1行8列的数组,可以和一个7行1列的数组进行运算,因为1行可以广播为7行,1列也可以广播为8列,经过广播后两数组之间的运算就相当于两个7行8列的数组之间的运算。
- 一个数组与常数之间的运算,也是广播机制在起作用。该常数分别与该数组中的每个元素运算。
具体见下方示例演示:
- 加法
print(n1+n2)
读代码体会广播机制
print(n1+n3)
读代码体会广播机制
print(n1+n4)
读代码体会广播机制
行、列都不相同的两个数组,但是只要后缘轴存在长度为1的,就嫩运算:
print(n3+n4)
- 减法
print(n2-n1)
- 乘法
print(n1*n2)
- 除法
print(n2/n1)
- 幂运算
print(n2**n1)
一、Python所有方向的学习路线
Python所有方向路线就是把Python常用的技术点做整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照上面的知识点去找对应的学习资源,保证自己学得较为全面。
二、学习软件
工欲善其事必先利其器。学习Python常用的开发软件都在这里了,给大家节省了很多时间。
三、入门学习视频
我们在看视频学习的时候,不能光动眼动脑不动手,比较科学的学习方法是在理解之后运用它们,这时候练手项目就很适合了。
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!