数据之路 Day8 Numpy包

转载：Numpy易百教程

转载：https://www.numpy.org.cn/article/basics/python_numpy_tutorial.html

1.什么是Numpy？

• NumPy是Python中科学计算的基础软件包。

• Numpy提供多维数组对象，多种派生对象（如：掩码数组、矩阵）以及用于快速操作数组的函数及API，

• Numpy包括数学、逻辑、数组形状变换、排序、选择、I/O 、离散傅立叶变换、基本线性代数、基本统计运算、随机模拟等。

• NumPy包的核心是ndarray对象。

 

2.数组对象ndarray

• Numpy的数组类被称为ndarray，别名为 array。

• Numpy的数组中所有元素类型都相同，并通过正整数元组索引。

• Numpy中，维度称为轴。轴的数目为rank。

- 数组属性：

ndarray.ndim 　　　　　　　  # 秩，即轴的数量或维度的数量
ndarray.shape　　 　　　　   # 数组的维度，对于矩阵，n 行 m 列
ndarray.size 　　           # 数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype ndarray      # 对象的元素类型
ndarray.itemsize ndarray   # 对象中每个元素的大小，以字节为单位
ndarray.data               # 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性
ndarray.real ndarray       # 元素的实部
ndarray.imag ndarray       # 元素的虚部
ndarray.flags ndarray      # 对象的内存信息
    C_CONTIGUOUS (C)       # 数据是在一个单一的C风格的连续段中
    F_CONTIGUOUS (F)       # 数据是在一个单一的Fortran风格的连续段中
    OWNDATA (O)            # 数组拥有它所使用的内存或从另一个对象中借用它
    WRITEABLE (W)          # 数据区域可以被写入，将该值设置为 False，则数据为只读
    ALIGNED (A)            # 数据和所有元素都适当地对齐到硬件上
    UPDATEIFCOPY (U)       # 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更

 

3.创建数组

- 创建1维数组

import numpy as np
m = [0, 1, 2, 3, 4]
n = (0, 1, 2, 3, 4)

a = np.array(m)
b = np.array(n)
c = np.asarray(m)
d = np.asarray(n)
e = np.arange(5)
# 创建一个由1数组的数组
f = np.ones(5)
# 创建一个由0组成的数组
g = np.zeros(5)
# 创建一个由随机值组成的数组
h = np.empty(5)
# 创建一个等差数列
i = np.linspace(1,5,5)
# 创建一个等比数列
j = np.logspace(0,9,10,base=2)
# 创建一个动态数组
k = np.frombuffer(b'hello world',dtype = 'S1')
# 使用迭代器创建ndarray
l = np.fromiter(iter(range(5)),dtype = float)
# 创建一个由常数填充的数组
m = np.full((2,2),7)
# 创建单位矩阵，函数中的参数n，则创建n * n的单位矩阵
n = np.eye(2)
# 创建随机数数组
o = np.random.random((2,2))

print(a) # >>> [0 1 2 3 4]
print(b) # >>> [0 1 2 3 4]
print(c) # >>> [0 1 2 3 4]
print(d) # >>> [0 1 2 3 4]
print(e) # >>> [0 1 2 3 4]
print(f) # >>> [1. 1. 1. 1. 1.]
print(g) # >>> [0. 0. 0. 0. 0.]
print(h) # >>> [1.14448054e+243 4.46811730e-091 4.47593816e-091 5.26482558e+170 4.47514014e+217]
print(i) # >>> [1. 2. 3. 4. 5.]
print(j) # >>> [  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]
print(k) # >>> [b'h' b'e' b'l' b'l' b'o' b' ' b'w' b'o' b'r' b'l' b'd']
print(l) # >>> [0. 1. 2. 3. 4.]
print(m) # >>> [[ 7.  7.][ 7.  7.]]
print(n) # >>> [[ 1.  0.][ 0.  1.]]
print(o) # >>> [[ 0.91940167  0.08143941][ 0.68744134  0.87236687]]

数组创建格式说明：

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
# object 数组或嵌套的数列    
# dtype  数据类型    
# copy   对象是否需要复制
# order  C为"行"方向,F为"列"方向,A为"任意"方向(默认)
# subok  默认返回一个与基类类型一致的数组
# ndmin  指定生成数组的最小维度

numpy.asarray(a, dtype = None, order = None)
# a 任意形式的输入参数,可以是：列表,列表的元组,元组, 元组的元组,元组的列表,多维数组

numpy.arange(start, stop, step, dtype)
# start    起始值，默认为0
# stop     终止值(不包含)
# step     步长，默认为1

numpy.empty(shape, dtype = float, order = 'C')　　
# shape 　　表示数组形状
# numpy.ones()、numpy.zeros()与numpy.empty()相同

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# start    序列的起始值
# stop     序列的终止值，如果endpoint为true，该值包含于数列中
# num      要生成的等步长的样本数量，默认为50
# endpoint 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True
# retstep  如果为 True 时，生成的数组中会显示间距，反之不显示

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
# start    序列的起始值为：base ** start
# stop     序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
# num      要生成的等步长的样本数量，默认为50)
# endpoint 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True
# base     对数 log 的底数，默认为10

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
# buffer   可以是任意对象，会以流的形式读入
# count    读取的数据数量，默认为-1，读取所有数据
# offset   读取的起始位置，默认为0

numpy.fromiter(iterable, dtype, count=-1)
# iterable 可迭代对象
# count     读取的数据数量，默认为-1,读取所有数据

如果创建一个2D（二维）数组，我们传递一个列表的列表（或者是一个序列的序列）给array()函数；

如果创建一个3D（三维）数组，我们就要传递一个列表的列表的列表；

如果创建一个4D（四维）数组，那就是列表的列表的列表的列表，以此类推。

- 创建多维数组

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

 

4.索引

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。

ndarray 数组可以基于 0 - n 的下标进行索引

import numpy as np

# 单元素索引
x = np.arange(10)
print(x[2])      # >>> 2
print(x[-2])     # >>> 8

# 多元素索引
y = np.arange(10).reshape(2,5)
print(y)         # >>> [[0 1 2 3 4][5 6 7 8 9]]
print(y[1,3])    # >>> 8
print(y[1,-1])   # >>> 9
print(y[0])      # >>> array([0, 1, 2, 3, 4])
print(y[0][2])   # >>> 2

 

- 花式索引 是获取数组中我们想要的特定元素的有效方法。

a = np.arange(0, 100, 10)
indices = [1, 5, -1]
b = a[indices]
print(a) # >>>[ 0 10 20 30 40 50 60 70 80 90]
print(b) # >>>[10 50 90]

- 缺省索引 不完全索引是从多维数组的第一个维度获取索引或切片的一种方便方法。 

a = np.arange(0, 100, 10)
b = a[:5]
c = a[a >= 50]
print(b) # >>>[ 0 10 20 30 40]
print(c) # >>>[50 60 70 80 90]

-where()函数是另外一个根据条件返回数组中的值的有效方法。只需要把条件传递给它，它就会返回一个使得条件为真的元素的列表。

a = np.arange(0, 100, 10)
b = np.where(a < 50) 
c = np.where(a >= 50)[0]
print(b) # >>>(array([0, 1, 2, 3, 4]),)
print(c) # >>>[5 6 7 8 9]

- 迭代

import numpy as np
 
a = np.arange(6).reshape(2,3)
print ('原始数组是：')
print (a)
print ('\n')
print ('迭代输出元素：')
for x in np.nditer(a):
    print (x, end=", " )
print ('\n')

输出结果为：原始数组是：[[0 1 2]
　　　　　　 　　　　　　[3 4 5]]
　　　　　　迭代输出元素：0, 1, 2, 3, 4, 5, 

==================================================================
import numpy as np
 
a = np.arange(9).reshape(3,3) 
print ('原始数组：')
for row in a:
    print (row)
 
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for element in a.flat:
    print (element,end = ",")

输出结果如下：原始数组：[0 1 2]
　　　　　　　　　　　　[3 4 5]
　　　　　　　　　　　　[6 7 8]　　　
　　　　　　　迭代后的数组：0,1,2,3,4,5,6,7,8,

5.形状操作

返回一个修改后的数组，但不要更改原始数组

# 如果在重新整形操作中将尺寸指定为-1，则会自动计算其他尺寸
numpy.reshape(arr, newshape, order='C')
# 数组转置
numpy.T
# 展平的数组元素，不改变数组形状
numpy.ravel()

 

6.数组连接

- numpy.concatenate：用于沿指定轴连接相同形状的两个或多个数组
  
  numpy.concatenate((a1, a2, ...), axis)
  # a1, a2, ...：相同类型的数组
  # axis：沿着它连接数组的轴，默认为 0

- numpy.stack：用于沿新轴连接数组序列
  numpy.stack((a1,a2, ...),axis)

- numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。
- numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。

 

7.数组分割

- numpy.split：沿特定的轴将数组分割为子数组
  
  numpy.split(ary, indices_or_sections, axis)
  # ary：被分割的数组；
  # indices_or_sections：果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）；
  # axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分。

- numpy.hsplit：用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
- numpy.vsplit：用于垂直轴分割，其分割方式与hsplit用法相同。

 

8.数组翻转

- numpy.transpose：用于对换数组的维度
  
  numpy.transpose(arr, axes)
  # arr：要操作的数组
  # axes：整数列表，对应维度，通常所有维度都会对换
  # 常用于高维数组翻转

- numpy.swapaxes：用于交换数组的两个轴
  
  numpy.swapaxes(arr, axis1, axis2)
  # arr：输入的数组
  # axis1：对应第一个轴的整数
  # axis2：对应第二个轴的整数

- numpy.rollaxis：向后滚动特定的轴到一个特定位置
  
  numpy.rollaxis(arr, axis, start)
  # arr：数组
  # axis：要向后滚动的轴，其它轴的相对位置不会改变
  # start：默认为零，表示完整的滚动。会滚动到特定位置。

 

9.广播

10.数组操作

- 新增

- numpy.append：函数在数组的末尾添加值。 
                追加操作会分配整个数组，并把原来的数组复制到新数组中。
                append 函数返回的始终是一个一维数组。

  numpy.append(arr, values, axis=None)
  # arr：输入数组
  # values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
  # axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。
    当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。

- numpy.insert：函数在给定索引之前，沿给定轴在输入数组中插入值。
                如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。
                此外，如果未提供轴，则输入数组会被展开。

  numpy.insert(arr, obj, values, axis)
  # arr：输入数组
  # obj：在其之前插入值的索引
  # values：要插入的值
  # axis：沿着它插入的轴，如果未提供，则输入数组会被展开

- 删除

- numpy.delete：函数返回从输入数组中删除指定子数组的新数组。 
                与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。

  numpy.delete(arr, obj, axis)
  # arr：输入数组
  # obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
  # axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

- 去重

- numpy.unique：函数用于去除数组中的重复元素。

  numpy.unique(arr, return_index, return_inverse, return_counts)
  # arr：输入数组，如果不是一维数组则会展开
  # return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
  # return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
  # return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

 

11.字符串函数

 

函数	描述	输入	输出
add()	对两个数组的逐个字符串元素进行连接	print (np.char.add(['hello'],[' xyz']))	['hello xyz']
		print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))	['hello abc' 'hi xyz']
multiply()	返回按元素多重连接后的字符串	print (np.char.multiply('Runoob ',3))	Runoob RunoobRunoob
center()	居中字符串	print (np.char.center('Runoob', 20,fillchar = '*'))	*******Runoob*******
capitalize()	将字符串第一个字母转换为大写	print (np.char.capitalize('runoob'))	Runoob
title()	将字符串的每个单词的第一个字母转换为大写	print (np.char.title('i like runoob'))	I Like Runoob
lower()	数组元素转换为小写	print (np.char.lower('RUNOOB'))	runoob
upper()	数组元素转换为大写	print (np.char.upper('runoob'))	RUNOOB
split()	指定分隔符对字符串进行分割，并返回数组列表	print (np.char.split ('i like runoob?'))  　　# 默认分隔符为空格	['i', 'like', 'runoob?']
		print (np.char.split ('www.runoob.com', sep = '.'))　　# 设置分隔符为“.”	['www', 'runoob','com']
splitlines()	返回元素中的行列表，以换行符分割	print (np.char.splitlines('i\nlike runoob?'))　　# \n，\r，\r\n 都可用作换行符	['i', 'like runoob?']
strip()	移除元素开头或者结尾处的特定字符	print (np.char.strip('ashok arunooba','a'))　　#移除字符串头尾的 a 字符	shok arunoob
		print (np.char.strip(['arunooba','admin','java'],'a'))　　#移除数组元素头尾的 a 字符	['runoob' 'dmin' 'jav']
join()	通过指定分隔符来连接数组中的元素	print (np.char.join(':','runoob'))　　# 操作字符串	r:u:n:o:o:b
		print (np.char.join([':','-'],['runoob','google']))　　# 指定多个分隔符操作数组元素	['r:u:n:o:o:b' 'g-o-o-g-l-e']
replace()	使用新字符串替换字符串中的所有子字符串	print (np.char.replace ('i like runoob', 'oo', 'cc'))	i like runccb
decode()	数组元素依次调用str.decode	print(np.char.encode('runoob', 'cp500'))	b'\x99\xa4\x95\x96\x96\x82'
encode()	数组元素依次调用str.encode	print (np.char.decode(np.char.encode('runoob', 'cp500'),'cp500'))	runoob

 

12.数学函数

三角函数：sin()、cos()、tan()
反三角函数：arcsin()、arccos()、arctan()
弧度换算角度：numpy.degrees()
舍入函数：numpy.around(a,decimals)　　
# a 输入数组
# decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

numpy.floor()：返回数字的下舍整数。
numpy.ceil()：返回数字的上入整数。

13.算术运算

加法：add()
减法：subtract()
乘法：multiply()
除法：divide()
倒数：numpy.reciprocal()
- numpy.power() # 此函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
- numpy.mod()    # 此函数返回输入数组中相应元素的除法余数。 
- numpy.real()  # 返回复数类型参数的实部。
- numpy.imag()  # 返回复数类型参数的虚部。
- numpy.conj()  # 返回通过改变虚部的符号而获得的共轭复数。
- numpy.angle() # 返回复数参数的角度。 函数的参数是degree。 如果为true，返回的角度以角度制来表示，否则为以弧度制来表示。

14.统计函数

- numpy.amin()             # 从给定数组中的元素沿指定轴返回最小值。
- numpy.amax()             # 从给定数组中的元素沿指定轴返回最大值。
- numpy.ptp()              # 返回沿轴的值的范围(最大值 - 最小值)。
- numpy.percentile()       # 百分位数是统计中使用的度量，表示小于这个值得观察值占某个百分比。 
  
  numpy.percentile(a, q, axis)
  # a 输入数组
  # q 要计算的百分位数，在 0 ~ 100 之间
  # axis 沿着它计算百分位数的轴
  
- numpy.median()          # 中值
- numpy.mean()            # 函数返回数组中元素的算术平均值。
- numpy.average()         # 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。
  
  # 如果 returned 参数设为 true，则返回权重的和  
  np.average([1,2,3,4],weights =  [4,3,2,1], returned =  True)

- numpy.std()标准差
- numpy.var()方差

 

15.排序

种类	速度	最坏情况	工作空间	稳定性
'quicksort'（快速排序）	1	O(n^2)	0	否
'mergesort'（归并排序）	2	O(n*log(n))	~n/2	是
'heapsort'（堆排序）	3	O(n*log(n))	0	否

 函数：

- numpy.sort()                    # 函数返回输入数组的排序副本。
  
  numpy.sort(a, axis, kind, order)
  # a 要排序的数组
  # axis 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序
  # kind 默认为'quicksort'(快速排序)
  # order 如果数组包含字段，则是要排序的字段。

- numpy.argsort()                 # 函数返回的是数组值从小到大的索引值。
- numpy.lexsort()                 # 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。
- numpy.argmax()                  # 返回沿给定轴返回最大元素的索引。 
- numpy.argmin()                  # 返回沿给定轴返回最小元素的索引。
- numpy.nonzero()                 # 函数返回输入数组中非零元素的索引。
- numpy.where()                   # 函数返回输入数组中满足给定条件的元素的索引。
- numpy.extract(condition, x)     # 函数返回满足任何条件的元素。

来源：https://www.cnblogs.com/Iceredtea/p/10970945.html