Python笔记_第五篇_Python数据分析基础教程_NumPy基础

1. NumPy的基础使用涵盖如下内容：

　　数据类型

　　数组类型

　　类型转换

　　创建数组

　　数组索引

　　数组切片

　　改变维度

2. NumPy数组对象：

　　NumPy中的ndarray是一个多维数组对象，该兑现共有两部分组成：

　　实际的数据

　　描述这些数据的元数据。

　　大部分的数组操作仅仅修改元数据部分而不改变底层的实际数据（其实就是一种浅拷贝理解）。

　　ndarray支持更高的维度，因为数组一般是同质的，所以数组所有的元素类型必须是一致的。

　　NumPy与Python一样数组的下标都是从0开始的。

　　

　　2.1 numpy.arange()创建数组和numpy.array()创建向量：

　　dtype：

import numpy as np

a = np.arange(5)
print(a.dtype)

　　arange(开始值，结束值，dtype)

　　dtype返回的是数据类型，这里返回的是int32或int64

　　shape：

import numpy as np

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

(5,)

　　我们用shape返回向量的维度，这里是5行，列为空，返回值为元组类型。

　　2.2 创建多维数组：

import numpy as np

a = np.array([np.arange(2),np.arange(2)])
print(a)
#[[0 1]
# [0 1]]

print(a.shape)
#(2, 2)

　我们将arange函数创建的数组作为向量/列表的元素，把这个列表作为参数传递给array函数，从而创建了一个2*2的多维数组。

　　2.3 选取数组元素：

　　有时候我们需要选取数组中的某个特定元素。喜爱宝是从0开始的

import numpy as np

a = np.array([[1,2],[3,4]])
print(a)
#[[1 2]
# [3 4]]

print(a[0,0])
#1

print(a[1,1])
#4

　　我们发现，在整个数组必须有一个大的括号包裹进里面的内容。

　　2.4 数据类型：

a = np.array([[1,2],[3,4]],dtype='f')

　　这些类型有些资料可以查找。另外还可以指定复数数组。

　　2.5 自定义数据类型和dtype类的属性：

　　查看占用字节数：

　　itemsize

import numpy as np

a = np.array([[1,2],[3,4]],dtype='f')
print(a.dtype.itemsize)

#4

　　自定义数据类型用dtype，然后在调用：

import numpy as np


t = np.dtype([('name',str,40),('numitems',int),('price',float)])
print(t)
#[('name', '<U40'), ('numitems', '<i4'), ('price', '<f8')]
print(t['name'])
#<U40
itemz = np.array([('Meaning of life DVD',42,3.14),('Butter',13,2.72)],dtype=t)
print(itemz[1])
#('Butter', 13, 2.72) 

　　

　　2.6 一维数组的索引和切片：

import numpy as np


a = np.arange(9)
print(a)
#[0 1 2 3 4 5 6 7 8]
print(a[3:7])
#[3 4 5 6]
print(a[:7:2])
#[0 2 4 6]
print(a[::-1])
#[8 7 6 5 4 3 2 1 0]

　　我们发现这和Python列表的索引和切片是一样的。

　　2.7 多维数组的切片和索引：

　　reshape：表示三维坐标来选定任意一个，即楼层、行号、列号

import numpy as np


b0 = np.arange(24)
print(b0)
#[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
b = np.arange(24).reshape(2,3,4)
print(b)
#[[[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
#
# [[12 13 14 15]
#  [16 17 18 19]
#  [20 21 22 23]]]
print(b.shape)
#(2, 3, 4)

print(b[:,0,0])
#[ 0 12]

　　

　　2.8 改变数组的维度：

　　reshape(a,newshape,order='C')

　　其中：

　　a：数组-需要处理的数据。

　　newshape：新格式-整数或数组（2,3）表示2行3列。新的形状应该与原来的形状金融。

　　order：情况比前面两个参数有些复杂，这里会用比较大的篇幅解释，并在后面给出一个比较容易的示例。

　　“C”指的是用类C写的读/索引顺序的元素，最后一个维度变化最快，第一个维度变化最慢。以二维数组为例，简单来讲就是横着读，横着写，优先读/写一行。

　　“F”是指用FORTRAN类索引顺序读/写元素，最后一个维度变化最慢，第一个维度变化最快。竖着读，竖着写，优先读/写一列。注意，“C”和“F”选项不考虑底层数组的内存布局，只引用索引的顺序。

　　“A”选项所生成的数组的效果与原数组a的数据存储方式有关，如果数据是按照FORTRAN存储的话，它的生成效果与”F“相同，否则与“C”相同。这里可能听起来有点模糊，下面会给出示例。

　　注：FORTRAN和C是两个语言，他们存储数组的方式不同，FORTRSAN为列有限，而C为行优先。在python中默认数组生成的时候是按照C的方式进行存储。但，很多时候我们需要调用Fortran的一些库进行数学计算，所以需要让numpy生成的数组变成按照FORTRAN的方式存储。

import numpy as np


b0 = np.arange(4)
print(b0)
#[0 1 2 3]

b1 = b0.reshape((2,2))
print(b1)
#[[0 1]
# [2 3]]

b2 = np.arange(8)

b3 = b2.reshape(2,2,2)
print(b3)
#[[[0 1]
#  [2 3]]
#
# [[4 5]
#  [6 7]]]

　　

　　ravel：

　　对矩阵进行展平操作：

import numpy as np


b0 = np.array([np.arange(2),np.arange(2)])
print(b0)
#
#[[0 1]
# [0 1]]

print(b0.ravel())
#[0 1 0 1]

　　flatten：

·　　也是展平操作，与ravel函数的功能相同。但是flatten函数会请求分配内存来报错结果，而ravel函数知识返回数组的一个视图（view）

　　resize：

　　与reshaple函数工呢狗一样，但是热死则会直接修改锁操作的数组。

　　transpose：

　　转置操作，属于数组的运算：

import numpy as np

b0 = np.array([np.arange(2),np.arange(2)])
print(b0)
#
#[[0 1]
# [0 1]]

print(b0.transpose())
#[[0 0]
# [1 1]]

　　

　　2.9 数组的组合：

　　vstack：

　　垂直组合

import numpy as np

a = np.arange(9).reshape(3,3)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

b = 2 * a
print(b)
#[[ 0  2  4]
# [ 6  8 10]
# [12 14 16]]

print(np.vstack((a,b)))
#[[ 0  1  2]
# [ 3  4  5]
# [ 6  7  8]
# [ 0  2  4]
# [ 6  8 10]
# [12 14 16]]

　　dstack：

　　深度组合：就是将一系列数组沿着纵轴（深度）方向进行层叠组合。举个例子，有若干张二维平面内的图像点阵数据，我们可以讲这些图像数据沿着纵轴方向层叠一起，就香香的解释了什么是深度组合。

import numpy as np

a = np.arange(9).reshape(3,3)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

b = 2 * a
print(b)
#[[ 0  2  4]
# [ 6  8 10]
# [12 14 16]]

print(np.dstack((a,b)))
#[[[ 0  0]
#  [ 1  2]
#  [ 2  4]]
#
# [[ 3  6]
#  [ 4  8]
#  [ 5 10]]
#
# [[ 6 12]
#  [ 7 14]
#  [ 8 16]]]

　　

　　hstack：

　　水平组合

import numpy as np

a = np.arange(9).reshape(3,3)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

b = 2 * a
print(b)
#[[ 0  2  4]
# [ 6  8 10]
# [12 14 16]]

print(np.hstack((a,b)))
#[[ 0  1  2  0  2  4]
# [ 3  4  5  6  8 10]
# [ 6  7  8 12 14 16]]

　　colum_stack：

　　列组合：column_stack函数对于一维数组将按照列方向进行组合。

import numpy as np

# 一维数组
oned = np.arange(2)
print(oned)
#[0 1]

twice_oned = 2 * oned
print(twice_oned)
#[0 2]

print(np.column_stack((oned,twice_oned)))
#[[0 0]
# [1 2]]

# 二维数组：对于二维数组column_stack的效果是hstack的效果是一样的。

　　

　　row_stack:

　　行组合：对于两个以为少数族直接层叠起来合成一个二维数组。

　　concatenate:

　　这个的效果和hstack的效果是一样的。

　　2.10 数组的分割：

　　hsplit：

　　水平分割

import numpy as np

a = np.arange(9)
a = a.reshape(3,3)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

# 水平分割为3个大小相同的子数组
print(np.hsplit(a,3))
#[array([[0],
#       [3],
#       [6]]), 
#array([[1],
#       [4],
#       [7]]), 
#array([[2],
#       [5],
#       [8]])]

　　

　　vsplit：

　　垂直分割：

　　dsplit：

　　深度分割：

　　split：

　　默认分割

print(np.split(a,3,axis=1))

　　1 = 垂直，0 =水平

 

　　2.11 数组的属性：

　　ndim属性，给出数组的维数或者数组轴的个数

　　size属性，给出数组元素的总个数

　　itemsize属性，给出数组中的元素在内存中所占的字节数

　　real属性，给出实部

　　image属性，给出虚部

　　flat属性将返回一个numpy.flatiter对象，这是获得flatiter对象的唯一方式，我们无法访问flatiter的构造函数。这个所谓“扁平迭代器”，可以让我们像遍历一维数组一样去遍历任意多维数组。

　　2.12 数组的转换：

　　tolist：

　　将numpy数组格式转换成python列表模式

import numpy as np

a = np.arange(9).reshape(3,3)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

b = a.tolist()
print(b,type(b))
# [6 7 8]]
#[[0, 1, 2], [3, 4, 5], [6, 7, 8]] <class 'list'>

　　　　

　　2.13 数组的运算：

　　加减乘除

　　转置：transpose

　　逆矩阵：linalg.inv()

import numpy as np

a = np.arange(9).reshape(3,3)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

b = np.linalg.pinv(a)
print(b)

#[[-5.55555556e-01 -1.66666667e-01  2.22222222e-01]
# [-5.55555556e-02  2.01227923e-16  5.55555556e-02]
# [ 4.44444444e-01  1.66666667e-01 -1.11111111e-01]]

　　对角线矩阵：eye

a = np.arange(9).reshape(3,3)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

b = np.eye(9,9)
print(b)

#[[1. 0. 0. 0. 0. 0. 0. 0. 0.]
# [0. 1. 0. 0. 0. 0. 0. 0. 0.]
# [0. 0. 1. 0. 0. 0. 0. 0. 0.]
# [0. 0. 0. 1. 0. 0. 0. 0. 0.]
# [0. 0. 0. 0. 1. 0. 0. 0. 0.]
# [0. 0. 0. 0. 0. 1. 0. 0. 0.]
# [0. 0. 0. 0. 0. 0. 1. 0. 0.]
# [0. 0. 0. 0. 0. 0. 0. 1. 0.]
# [0. 0. 0. 0. 0. 0. 0. 0. 1.]]

　　零矩阵：zeros

　　空矩阵：empty

　　三角矩阵：diag

import numpy as np

a = np.arange(9).reshape(3,3)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

b = np.diag((1,2,3))
print(b)
#[[1 0 0]
# [0 2 0]
# [0 0 3]]

　　

　　2.14 矩阵库Matrix函数：

　　matrices必须是二维的，但是numpy arrays（ndarrays可以是多维的），matrix最主要的优势就是类似于matlab中的格式很相似，不用方括号括起来看起来不那么方便。但是是一种矩阵格式的数据不是ndarrays数据的格式，同样也可以通过tolist进行转化

import numpy as np

a = np.mat('4 3;2 1')
print(a)
#[[4 3]
# [2 1]]
print(type(a))
#<class 'numpy.matrixlib.defmatrix.matrix'>
b = a.tolist()
print(b,type(b))
#[[4, 3], [2, 1]] <class 'list'>