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

上一篇doris配置自动拉起服务-supervisor

下一篇python-数据分析-Numpy-2-数组对象方法

本文作者：little小新

本文链接：https://www.cnblogs.com/littlecc/p/18239032

posted @ 2024-06-09 02:16 little小新阅读(35) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

littlecc

无限制的技术都要学

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

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

`NumpPy 的说明`

`numpy模块的基础使用`

`数组对象的属性`

`数组的索引运算`

`花式索引`

`布尔索引`

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

公告

常用链接

我的标签

随笔分类

随笔档案

相册

阅读排行榜

评论排行榜

推荐排行榜

最新评论

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

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

	# -- 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个元素

	# -- 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]]
	'''

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