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, 1for _ 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 377610 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.406322530.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]) #9print(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 numpyarray = 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]))
