NumPy基本操作,常用函数

最新推荐文章于 2025-03-09 22:38:21 发布

原创最新推荐文章于 2025-03-09 22:38:21 发布 · 97 阅读

0 ·

CC 4.0 BY-SA版权

内容索引

该小结主要介绍了NumPy数组的基本操作。

子目1中，介绍创建和索引数组，数据类型，dtype类，自定义异构数据类型。

子目2中，介绍数组的索引和切片，主要是对[]运算符的操作。

子目3中，介绍如何改变数组的维度，分别介绍了ravel函数、flatten函数、transpose函数、resize函数、reshape函数的用法。

In [1]:

Python

%pylab inline

1	< span class = "o" > % < / span > < span class = "k" > pylab < / span > inline

Python

Populating the interactive namespace from <a href="https://www.168seo.cn/tag/numpy" title="View all posts in numpy" target="_blank">numpy</a> and matplotlib

1	Populating the interactive namespace from numpy and matplotlib

ndarray是一个多维数组对象，该对象由实际的数据、描述这些数据的元数据组成，大部分数组操作仅仅修改元数据部分，而不改变底层的实际数据。

用arange函数创建数组

In [2]:

Python

a = arange(5) #生成5个元素的数组 a.dtype #显示a的类型

a = arange ( 5 )

#生成5个元素的数组

a . dtype

#显示a的类型

Out[2]:

Python

dtype('int64')

1	dtype ( 'int64' )

In [3]:

Python

a

1	< span class = "n" > a < / span >

Out[3]:

Python

array([0, 1, 2, 3, 4])

1	array ( [ 0 , 1 , 2 , 3 , 4 ] )

In [4]:

Python

a.shape #获取数组内是几行几列

1 2	< span class = "n" > a < / span > < span class = "o" > . < / span > < span class = "n" > shape < / span > #获取数组内是几行几列

Out[4]:

Python

(5,)

( 5 , )

数组的shape属性返回一个元祖(tuple)，元组中的元素即NumPy数组每一个维度的大小。

1. 创建多维数组

array函数可以依据给定的对象生成数组。给定的对象应是类数组，如python的列表、numpy的arange函数

In [5]:

Python

m = array([arange(2), arange(2)]) 生成一个两行两列的数组

m = array ( [ arange ( 2 ) , arange ( 2 ) ] )

生成一个两行两列的数组

In [6]:

Python

print m print m.shape print type(m) print type(m.shape)

print m

print m . shape

print type ( m )

print type ( m . shape )

Python

[[0 1] [0 1]] (2, 2) <type '<a href="https://www.168seo.cn/tag/numpy" title="View all posts in numpy" target="_blank">numpy</a>.ndarray'> <type 'tuple'>

[ [ 0 1 ]

[ 0 1 ] ]

( 2 , 2 )

< type 'numpy.ndarray' >

< type 'tuple' >

选取元素

In [7]:

Python

a = array([[1,2],[3,4]]) print a[0,0] print a[0,1]

print a [ 0 , 0 ]

print a [ 0 , 1 ]

Python

1 2

NumPy数据类型

Numpy除了Python支持的整型、浮点型、复数型之外，还添加了很多其他的数据类型。

Type Remarks Character code bool_ compatible: Python bool '?' bool8 8 bits
Integers:

byte compatible: C char 'b' short compatible: C short 'h' intc compatible: C int 'i' int_ compatible: Python int 'l' longlong compatible: C long long 'q' intp large enough to fit a pointer 'p' int8 8 bits
int16 16 bits
int32 32 bits
int64 64 bits
Unsigned integers:

ubyte compatible: C unsigned char 'B' ushort compatible: C unsigned short 'H' uintc compatible: C unsigned int 'I' uint compatible: Python int 'L' ulonglong compatible: C long long 'Q' uintp large enough to fit a pointer 'P' uint8 8 bits
uint16 16 bits
uint32 32 bits
uint64 64 bits
Floating-point numbers:

half 'e' single compatible: C float 'f' double compatible: C double
float_ compatible: Python float 'd' longfloat compatible: C long float 'g' float16 16 bits
float32 32 bits
float64 64 bits
float96 96 bits, platform?
float128 128 bits, platform?
Complex floating-point numbers:

csingle 'F' complex_ compatible: Python complex 'D' clongfloat 'G' complex64 two 32-bit floats
complex128 two 64-bit floats
complex192 two 96-bit floats, platform?
complex256 two 128-bit floats, platform?
Any Python object:

object_ any Python object 'O'

每一种数据类型均有对应的类型转换函数

In [8]:

Python

print float64(42) print int8(42.0) print bool(42) print float(True)

print float64 ( 42 )

print int8 ( 42.0 )

print bool ( 42 )

print float ( True )

Python

42.0 42 True 1.0

42.0

True

1.0

In [9]:

Python

arange(8, dtype=uint16)

1	< span class = "n" > arange < / span > < span class = "p" > ( < / span > < span class = "mi" > 8 < / span > < span class = "p" > , < / span > < span class = "n" > dtype < / span > < span class = "o" >= < / span > < span class = "n" > uint16 < / span > < span class = "p" > ) < / span >

Out[9]:

Python

array([0, 1, 2, 3, 4, 5, 6, 7], dtype=uint16)

1	array ( [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ] , dtype = uint16 )

复数不能转换成整数和浮点数

Numpy数组中每一个元素均为相同的数据类型，现在给出单个元素所占字节

In [10]:

Python

a.dtype

1	< span class = "n" > a < / span > < span class = "o" > . < / span > < span class = "n" > dtype < / span >

Out[10]:

Python

dtype('int32')

1	dtype ( 'int32' )

In [11]:

Python

a.dtype.itemsize

1	< span class = "n" > a < / span > < span class = "o" > . < / span > < span class = "n" > dtype < / span > < span class = "o" > . < / span > < span class = "n" > itemsize < / span >

Out[11]:

Python

dtype类的属性

In [12]:

Python

t = dtype('float64') print t.char print t.type print t.str

print t . char

print t . type

print t . str

Python

d <type 'numpy.float64'> <f8

< type 'numpy.float64' >

< f8

str属性可以给出数据类型的字符串表示，该字符串的首个字符表示字节序，然后是字符编码，然后是所占字节数字节序是指位长为32和64的字（word）存储的顺序，包括大端序(big-endian)和小端序(little-endian)。大端序是将最高位字节存储在最低的内存地址处，用>表示；与之相反，小端序是将最低位字节存储在最低的内存地址处，用<表示。

创建自定义数据类型

自定义数据类型是一种异构数据类型，可以当做用来记录电子表格或数据库中一行数据的结构。

下面我们创建一种自定义的异构数据类型，该数据类型包括一个用字符串记录的名字、一个用整数记录的数字以及一个用浮点数记录的价格。

In [13]:

Python

t = dtype([('name', str_, 40), ('numitems', int32), ('price', float32)])

t = dtype ( [ ( 'name' , str_ , 40 ) , ( 'numitems' , int32 ) , ( 'price' , float32 ) ] )

In [14]:

Python

t

1	< span class = "n" > t < / span >

Out[14]:

Python

dtype([('name', 'S40'), ('numitems', '<i4'), ('price', '<f4')])

1	dtype ( [ ( 'name' , 'S40' ) , ( 'numitems' , '<i4' ) , ( 'price' , '<f4' ) ] )

In [15]:

Python

t['name']

1	< span class = "n" > t < / span > < span class = "p" > [ < / span > < span class = "s1" > 'name' < / span > < span class = "p" > ] < / span >

Out[15]:

Python

dtype('S40')

1	dtype ( 'S40' )

In [16]:

Python

itemz = array([('Meaning of life DVD', 32, 3.14), ('Butter', 13, 2.72)], dtype=t)

itemz = array ( [ ( 'Meaning of life DVD' , 32 , 3.14 ) , ( 'Butter' , 13 , 2.72 ) ] , dtype = t )

In [17]:

Python

itemz[1]

1	< span class = "n" > itemz < / span > < span class = "p" > [ < / span > < span class = "mi" > 1 < / span > < span class = "p" > ] < / span >

Out[17]:

Python

('Butter', 13, 2.7200000286102295)

1	( 'Butter' , 13 , 2.7200000286102295 )

2. 数组的索引和切片

In [18]:

Python

a = arange(9) #下标0-7，以2为步长 print a[:7:2] #以负数下标翻转数组 print a[::-1] Out[21]: array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) print a[::-2] Out[22]: array([9, 7, 5, 3, 1])

a = arange ( 9 )

#下标0-7，以2为步长

print a [ : 7 : 2 ]

#以负数下标翻转数组

print a [ :: - 1 ]

Out [ 21 ] : array ( [ 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 ] )

print a [ :: - 2 ]

Out [ 22 ] : array ( [ 9 , 7 , 5 , 3 , 1 ] )

多维数组的切片和索引

In [19]:

Python

b = arange(24).reshape(2,3,4) print b.shape print b

b = arange ( 24 ) . reshape ( 2 , 3 , 4 )

print b . shape

print b

Python

(2, 3, 4) [[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]]

( 2 , 3 , 4 )

[ [ [ 0 1 2 3 ]

[ 4 5 6 7 ]

[ 8 9 10 11 ] ]

[ [ 12 13 14 15 ]

[ 16 17 18 19 ]

[ 20 21 22 23 ] ] ]

用三维坐标选定任意一个房间，即楼层、行号、列号

In [20]:

Python

#选取第一层楼所有房间 print b[0] print print b[0, :, :]

#选取第一层楼所有房间

print b [ 0 ]

print

print b [ 0 , : , : ]

Python

[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]

[ [ 0 1 2 3 ]

[ 4 5 6 7 ]

[ 8 9 10 11 ] ]

[ [ 0 1 2 3 ]

[ 4 5 6 7 ]

[ 8 9 10 11 ] ]

In [21]:

Python

#多个冒号用一个省略号代替 b[0, ...]

1 2	< span class = "c1" > #多个冒号用一个省略号代替</span> < span class = "n" > b < / span > < span class = "p" > [ < / span > < span class = "mi" > 0 < / span > < span class = "p" > , < / span > < span class = "o" > . . . < / span > < span class = "p" > ] < / span >

Out[21]:

Python

array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])

array ( [ [ 0 , 1 , 2 , 3 ] ,

[ 4 , 5 , 6 , 7 ] ,

[ 8 , 9 , 10 , 11 ] ] )

In [22]:

Python

#间隔选元素 b[0,1,::2] 一层楼,第一个房间步长是2

#间隔选元素

b [ 0 , 1 , :: 2 ]

一层楼 ,第一个房间步长是 2

Out[22]:

Python

array([4, 6])

1	array ( [ 4 , 6 ] )

In [23]:

Python

#多维数组执行翻转一维数组的命令，将在最前面的维度上翻转元素的顺序 b[::-1]

1 2	< span class = "c1" > #多维数组执行翻转一维数组的命令，将在最前面的维度上翻转元素的顺序</span> < span class = "n" > b < / span > < span class = "p" > [ :: < / span > < span class = "o" > - < / span > < span class = "mi" > 1 < / span > < span class = "p" > ] < / span >

Out[23]:

Python

array([[[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]], [[ 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 ] ] ,

[ [ 0 , 1 , 2 , 3 ] ,

[ 4 , 5 , 6 , 7 ] ,

[ 8 , 9 , 10 , 11 ] ] ] )

In [24]:

Python

b[::-1,::-1,::-1]

b [ :: - 1 , :: - 1 , :: - 1 ]

Out[24]:

Python

array([[[23, 22, 21, 20], [19, 18, 17, 16], [15, 14, 13, 12]], [[11, 10, 9, 8], [ 7, 6, 5, 4], [ 3, 2, 1, 0]]])

array ( [ [ [ 23 , 22 , 21 , 20 ] ,

[ 19 , 18 , 17 , 16 ] ,

[ 15 , 14 , 13 , 12 ] ] ,

[ [ 11 , 10 , 9 , 8 ] ,

[ 7 , 6 , 5 , 4 ] ,

[ 3 , 2 , 1 , 0 ] ] ] )

3. 改变数组的维度

ravel 完成展平操作

In [25]:

Python

b.ravel() #所有的列表转成一个列表

1 2	< span class = "n" > b < / span > < span class = "o" > . < / span > < span class = "n" > ravel < / span > < span class = "p" > ( ) < / span > #所有的列表转成一个列表

Out[25]:

Python

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])

1 2	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 ] )

flatten 也是展平

flatten函数会请求分配内存来保存结果，而ravel函数只是返回数组的一个视图（view）

In [26]:

Python

b.flatten()

1	< span class = "n" > b < / span > < span class = "o" > . < / span > < span class = "n" > flatten < / span > < span class = "p" > ( ) < / span >

Out[26]:

Python

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])

1 2	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 ] )

用元组设置维度

In [27]:

Python

b.shape = (6, 4)

b . shape = ( 6 , 4 )

In [28]:

Python

b

1	< span class = "n" > b < / span >

Out[28]:

Python

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]])

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 ] ] )

transpose转置矩阵

In [29]:

Python

b.transpose()

1	< span class = "n" > b < / span > < span class = "o" > . < / span > < span class = "n" > transpose < / span > < span class = "p" > ( ) < / span >

Out[29]:

Python

array([[ 0, 4, 8, 12, 16, 20], [ 1, 5, 9, 13, 17, 21], [ 2, 6, 10, 14, 18, 22], [ 3, 7, 11, 15, 19, 23]])

array ( [ [ 0 , 4 , 8 , 12 , 16 , 20 ] ,

[ 1 , 5 , 9 , 13 , 17 , 21 ] ,

[ 2 , 6 , 10 , 14 , 18 , 22 ] ,

[ 3 , 7 , 11 , 15 , 19 , 23 ] ] )

resize和reshape函数功能一样 但resize会直接改变所操作的数组

In [30]:

Python

b.reshape(2,3,4)

b . reshape ( 2 , 3 , 4 )

Out[30]:

Python

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]]])

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 ] ] ] )

In [31]:

Python

b

1	< span class = "n" > b < / span >

Out[31]:

Python

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]])

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 ] ] )

In [32]:

Python

b.resize(2,12)

1	< span class = "n" > b < / span > < span class = "o" > . < / span > < span class = "n" > resize < / span > < span class = "p" > ( < / span > < span class = "mi" > 2 < / span > < span class = "p" > , < / span > < span class = "mi" > 12 < / span > < span class = "p" > ) < / span >

In [33]: