python-数据分析-NumPy的应用-1、基础

1、安装python 数据分析的三大神器

pip install numpy pandas matplotlib

 

NumpPy 的说明

Numpy 是一个开源的 Python 科学计算库，用于快速处理任意维度的数组。Numpy 支持常见的数组和矩阵操作、
对于同样的数值计算任务，使用 NumPy 不仅代码要简洁的多，而且 NumPy 在性能上也远远优于原生 Python、
至少是一到两个数量级的差距，而且数据量越大，NumPy 的优势就越明显。

NumPy 最为核心的数据类型是ndarray，使用ndarray可以处理一维、二维和多维数组，该对象相当于是一个快速而灵活的大数据容器。
NumPy 底层代码使用 C 语言编写，解决了 GIL 的限制，ndarray在存取数据的时候，数据与数据的地址都是连续的，
这确保了可以进行高效率的批量操作，性能上远远优于 Python 中的list；另一方面ndarray对象提供了更多的方法来处理数据，
尤其获取数据统计特征的方法，这些方法也是 Python 原生的list没有的。

numpy模块的基础使用

# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import numpy
import pandas
import matplotlib

#创建数组对象 - ndarray 创建ndarry有多种方法
# 1、是哦那个array函数、通过list创建数组对象
array1 = numpy.array([1, 2, 3, 4, 5])
print(array1)   #[1 2 3 4 5]
array2 = numpy.array([[1, 2, 3], [4, 5, 6]])    #输出会自动换行
print(array2)
#[[1 2 3]
# [4 5 6]]

# 2、使用arange函数、指定取值范围和跨度创建数组对象
# arange(start, stop, step)
array3 = numpy.arange(0, 20, 2)
print(array3)   #[ 0  2  4  6  8 10 12 14 16 18]

# 3、使用linspace函数、用指定范围和元素个数创建数组对象、生成等差数列
# linspace(start, stop, num)
array4 = numpy.linspace(-1, 1, 11)
print(array4)   #[-1.  -0.8 -0.6 -0.4 -0.2  0.   0.2  0.4  0.6  0.8  1. ]


# 4、使用logspace函数、生成等比数列
# logspace(start, stop, num, base)
#start=1表示2的1次方
#stop=10表示2的10次方
#num=10表示生成10个数
#base=2表示以2为底
array5 = numpy.logspace(1, 10, num=10, base=2)  ##含义是生成 10 个数，这些数在对数基数为 2的刻度上从 2的1次方到2的10次方均匀的分布
print(array5)   #[   2.    4.    8.   16.   32.   64.  128.  256.  512. 1024.]

#注意：等比数列的起始值是$2^1$，等比数列的终止值是$2^{10}$，num是元素的个数，base就是底数。

# 5、通过fromstring函数从字符串提取数据创建数组对象
# fromstring(string, sep, dtype)
# string：字符串
# sep：分隔符
# dtype：数据类型 i8表示int64
array6 = numpy.fromstring('1 2 3 4 5', sep=' ', dtype='i8')
print(array6)   #[1 2 3 4 5]

# 6、 通过fromiter函数从生成器（迭代器）中获取数据创建数组对象
def fib(how_many):
    a, b = 0, 1
    for _ in range(how_many):   # _ :表示忽略变量
        a, b = b, a + b         #生成斐波那契数列
        yield a
gen = fib(20)
array7 = numpy.fromiter(gen, dtype='i8')
print(array7)
'''
[   1    1    2    3    5    8   13   21   34   55   89  144  233  377
  610  987 1597 2584 4181 6765]
'''

# 7、 使用numpy.random模块的函数生成随机数创建数组对象
#产生10个$[0, 1)范围的随机小数
array8 = numpy.random.rand(10)
print(array8)
"""
[0.97779416 0.65321969 0.92930144 0.77446802 0.8259189  0.40632253
 0.04318595 0.75099474 0.28481314 0.46203626]
"""

#产生10个$[1, 100)$范围的随机整数，代码：
array9 = numpy.random.randint(1, 100, 10)
print(array9)

#产生20个$\small{\mu=50}$，$\small{\sigma=10}$的正态分布随机数，代码：
array10 = numpy.random.normal(50, 10, 20)
print(array10)

#产生$[0, 1)$范围的随机小数构成的3行4列的二维数组，代码：
#numpy.random.rand(3, 4) -> 3行4列的二维数组
array11 = numpy.random.rand(3, 4)
print(array11)
'''
[[0.2151178  0.39222962 0.65308132 0.55345128]
 [0.34604538 0.02472764 0.3164634  0.57257634]
 [0.5175043  0.10675846 0.45963431 0.64124903]]
'''

#产生$[1, 100)$范围的随机整数构成的三维数组，代码：
#numpy.random.randint(1, 100, (3, 4, 5)) -> 4行5列的三维数组
array12 = numpy.random.randint(1, 100, (3, 4, 5))
print(array12)
'''
[[[26  8 15 35  4]
  [85 33 74 36 18]
  [69 73 29 26 92]
  [82  3 58  8 68]]

 [[98 71 32 35 24]
  [57 51 91 73 81]
  [88 32 18 84 60]
  [25 43 89 23 18]]

 [[23 50 16 40 32]
  [90 86 13 88 24]
  [35 83 30 50 45]
  [28 69 34  1 40]]]
'''

# 8、 创建全0、全1或指定元素的数组
#zeros(shape, dtype=float)
#shape：数组形状，如(3, 4)表示3行4列
#dtype：数据类型，默认为float
array13 = numpy.zeros((3, 4))   #全0
print(array13)
'''
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
'''

#ones(shape, dtype=float)
array14 = numpy.ones((3, 4))   #全1
print(array14)


#使用full函数，代码：
#full(shape, fill_value, dtype=None)
#shape：数组形状，如(3, 4)表示3行4列
#fill_value：填充值
#dtype：数据类型，默认为float
array15 = numpy.full((3, 4), 10)
print(array15)
'''
[[10 10 10 10]
 [10 10 10 10]
 [10 10 10 10]]
'''
print("\n")
# 9、使用eye函数创建单位矩阵
#eye(N, M=None, k=0, dtype=float)
#N：矩阵的行数
#M：矩阵的列数，默认为N
#k：对角线偏移量，默认为0，表示对角线为1
#dtype：数据类型，默认为float
# array16 = numpy.eye(4, 4)
numpy.eye(4)
print(numpy.eye(4))
'''
[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]
'''
print("\n")
# 10、读取图片获得对应的三位数组
array17 = plt.imread('images/1.jpg')    #import matplotlib.pyplot as plt
print(array17)
#计算机系统中的图片通常由若干行若干列的像素点构成，而每个像素点又是由红绿蓝三原色构成的，刚好可以用三维数组来表示。读取图片用到了matplotlib库的imread函数

数组对象的属性

# -*- coding: utf-8 -*-
#数组对象的属性

import numpy
import matplotlib
import pandas

# 1、 size属性：获取数组元素个数
array1 = numpy.arange(1, 100, 2)    # 生成一个1-99之间，步长为2的数组
# print(array1)
print(array1.size)  #50
array2 = numpy.random.rand(3, 4)  # 生成一个3行4列的随机数组
print(array2.size)  #12

# 2、shape获取数组的形状
print(array1.shape) #(50,) 50个元素
print(array2.shape) #(3, 4) 3行4列

# 3、dtype属性、获取数组元素的数据类型
print(array1.dtype) #int32
print(array2.dtype) #float64

# -*- coding: utf-8 -*-
#数组对象的属性

import numpy
import matplotlib
import pandas

# 1、 size属性：获取数组元素个数
array1 = numpy.arange(1, 100, 2)    # 生成一个1-99之间，步长为2的数组
# print(array1)
print(array1.size)  #50
array2 = numpy.random.rand(3, 4)  # 生成一个3行4列的随机数组
print(array2.size)  #12

# 2、shape获取数组的形状
print(array1.shape) #(50,) 50个元素
print(array2.shape) #(3, 4) 3行4列

# 3、dtype属性、获取数组元素的数据类型
print(array1.dtype) #int32
print(array2.dtype) #float64

# 4、ndim属性：获取数组的维度
print(array1.ndim)  #1  表示数组是1维的
print(array2.ndim)  #2 表示数组是二维的

# 5、itemsize属性：获取数组单个元素占用内存空间的字节数
print(array1.itemsize)  #4 表示数组中每个元素占用4个字节
print(array2.itemsize)  #8 表示数组中每个元素占用8个字节

# nbytes属性：获取数据所有元素占用内存空间的字节数
print(array1.nbytes)    #200 表示数组中每个元素占用4个字节，总共50个元素
print(array2.nbytes)    #96 表示数组中每个元素占用8个字节，总共12个元素

ndarray对象元素的数据类型可以参考如下所示的表格

 

数组的索引运算

# -*- coding: utf-8 -*-
#数组的索引运算
'''
和 Python 中的列表类似，NumPy 的ndarray对象可以进行索引和切片操作，通过索引可以获取或修改数组中的元素，通过切片操作可以取出数组的一部分，我们把切片操作也称为切片索引。
'''

import numpy

# 1、普通索引
#类似于python中list类型的索引运算
array1 = numpy.arange(1, 10)
print(array1)   #[1 2 3 4 5 6 7 8 9]
print(array1[0], array1[array1.size - 1])   #1 9    #array1.size 获取数组长度
print(array1[-array1.size], array1[-1])     #1 9

#numpy.array() 创建数组
array2 = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(array2[2])    #[7 8 9]

print(array2[0][0]) #1
print(array2[-1][-1])   #9

print(array2[1][1]) #5
print(array2[1, 1]) #5  array2[1, 1] == array2[1][1]

array2[1][1] = 10   #修改数组元素、赋值
print(array2)
'''
[[1 2 3]
 [4 10 6]
 [7 8 9]]
'''

array2[1] = [10, 11, 12]    #修改数组元素、赋值
print(array2)
'''
[[1 2 3]
 [10 11 12]
 [7 8 9]]
'''
print("\n")


#2、切片索引
#切片索引是形如[开始索引:结束索引:跨度]的语法，通过指定开始索引（默认值无穷小）、结束索引（默认值无穷大、等于最大的行数或列数）和跨度（默认值1）
#因为开始索引、结束索引和步长都有默认值，所以它们都可以省略，如果不指定步长，第二个冒号也可以省略
#一维数组的切片运算跟 Python 中的list类型的切片非常类似，此处不再赘述，二维数组的切片可以参考下面的代码
array3 = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(array3)
#array3[选择行, 选择列]
print(array3[:2, 1:])  #:2 = 0:2:1 选择前两行（第0行和第1行）。   #1: = 1:3:1 选择从第二列（第1列）到末尾的所有列
'''
#这样看 
第 0 1  2 列
 [[1 2 3]    #第0行
  [4 5 6]    #第1行
  [7 8 9]]
 
#输出
[[2 3]
 [5 6]]
'''

print(array3[2, :]) #2 第二行 、[:] = 0:3:1 选择所有列   #[7 8 9]

print(array3[:, :2])    #[:, :2] = 0:3:1, 0:2:1 = 选择所有行、第0列到第1列（第0列和第1列)
'''
[[1 2]
 [4 5]
 [7 8]]
'''

print(array3[::2, ::2]) #[::2, ::2] = 0:3:2, 0:3:2 = 选择所有行、所有列，跨度是2
'''
[[1 3]
 [7 9]]
'''

print(array3[::-2, ::-2])   #[::-2, ::-2] = 3:0:-2, 3:0:-2 = 选择所有行、所有列，跨度是-2
'''
[[9 7]
 [3 1]]
'''

图1：二维数组的普通索引

二维数组的切片索引

花式索引

# -*- coding: utf-8 -*-
#花式索引
#花式索引是用保存整数的数组充当一个数组的索引，这里所说的数组可以是 NumPy 的ndarray，也可以是 Python 中list、tuple等可迭代类型，可以使用正向或负向索引。

import numpy
array1 = numpy.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
# print(array1)
print(array1[[0, 1, 1, -1, -2, 2]])  #[1 2 2 9 8 3]

print("-------------------")

array2 = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) #3维数组
print(array2[[0, 2]])  #array2[[0, 2]] 表示获取array2的第0行和第2行

print("-------------------")
print(array2)
print(array2[[0, 2], [1, 2]])   #array2[[0, 2], [1, 2]] 表示获取array2的第0行第一列、第二行的第二列
#可以这样看[0][1] [2][2]
'''
[[1 2 3]
 [4 5 6]
 [7 8 9]]

[2 9]   #拿到的值
'''
print("-------------------")
print(array2[[0, 2], 1])    #array2[[0, 2], 1] 表示获取array2的第0行的第1列和第2行的第1列
'''
[[1 2 3]
 [4 5 6]
 [7 8 9]]

[2 8]
'''

布尔索引

# -*- coding: utf-8 -*-
#布尔索引
#布尔索引就是通过保存布尔值的数组充当一个数组的索引，布尔值为True的元素保留，布尔值为False的元素不会被选中。布尔值的数组可以手动构造，也可以通过关系运算来产生。

import numpy

array = numpy.array([1, 2, 3, 4, 5, 6])
array2 = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(array[[True, False, True, False, True, False]])   #[1 3 5]
print('---------------------------')

print(array > 5)    #[False False False False False  True]
print('---------------------------')
#~: 取反
print(~(array > 5)) #[ True  True  True  True  True False]
print('---------------------------')

print(array % 2 == 0)   #[False  True False  True False  True]
print('---------------------------')

print(array2[array2 % 2 == 0])  #[2 4 6 8]
print('---------------------------')

print((array > 5) & (array % 2 == 0))   #[False False False False False  True]
#说明：&运算符可以作用于两个布尔数组，如果两个数组对应元素都是True，那么运算的结果就是True，否则就是False，
# #该运算符的运算规则类似于 Python 中的 and 运算符，只不过作用的对象是两个布尔数组
print('---------------------------')

print(array[(array > 5) & (array % 2 == 0)])    #[6]
print('---------------------------')

print(array[(array > 5) | (array % 2 == 0)])    #[2 4 6]
#说明：|运算符可以作用于两个布尔数组，如果两个数组对应元素都是False，那么运算的结果就是False，否则就是True，
# 该运算符的运算规则类似于 Python 中的 or 运算符，只不过作用的对象是两个布尔数组。
print('---------------------------')

 

案例：通过数组切片处理图像

可以用三维数组来表示图像，那么通过图像对应的三维数组进行操作，就可以实现对图像的处理，如下所示。

# -*- coding: utf-8 -*-
#案例、通过数组切片处理图像
import matplotlib.pyplot as plt
import numpy
import matplotlib

#读入图片创建三位数组对象
guido_img = plt.imread('images/2.jpg')  # 读取图片
plt.imshow(guido_img)   # 显示图片

print(plt.imshow(guido_img))    #AxesImage(size=(2307, 3461))

#对数组的0轴进行反向切片，实现图像的垂直翻转。
print(plt.imshow(guido_img[::-1]))