Numpy 基础 一

# coding:utf-8


import numpy as np
import pandas as pd

# 1. 获得 Numpy 的版本信息
print(np.__version__)
print(pd.__version__)

# ==================================================================================
# Ndarray 对象
# np.ndarray(object, dtype = None, copy=true, order = None, subok = False, ndmin = 0)
# ==================================================================================

# object: 数组或者嵌套的数列
# dtype: 数组元素的类型
# copy: 对象是否需要复制
# order: 创建数组的样式， C 行方向， F 列方向， A 任意方向
# subok: 返回一个与基类型一致的数组
# ndmin：制定生成数组的最小维度

arr = np.ndarray([1, 2, 3, 4, 5, 6])
# 数组的属性

# 秩，即轴的数量或维度的数量
arr.ndim

# 数组的维度，对于矩阵，n 行 m 列
arr.shape

# 数组元素的总个数，相当于 .shape 中 n*m 的值
arr.size

# ndarray 对象的元素类型
arr.dtype

# ndarray 对象中每个元素的大小，以字节为单位
arr.itemsize

# ndarray 对象的内存信息
arr.flags
# print(arr.flags)
# ndarray元素的实部
arr.real

# ndarray 元素的虚部
arr.imag

# 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。
arr.data

# ######## 创建数组

# ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建

# arr1 = np.empty(shape, dtype = float, order = 'C')
# numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：
arr = np.empty((3, 3), dtype=int, order='C')


# 创建指定大小的数组，数组元素以 0 来填充
arr2 = np.zeros([3, 3], dtype=int, order='C')

# 创建指定形状的数组，数组元素以 1 来填充
arr_ones = np.ones([5, 7], dtype=int, order='C')


# ## 从已有的数组创建数组

# numpy.asarray(a, dtype = None, order = None)
# 参数: a - 形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
arr_asarray = np.asarray([(1, 2, 3), (4, 5)])


# numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
# numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象
# 参数； - count: 读取的数据数量，默认为-1，读取所有数据
s = b'Hello World'
a = np.frombuffer(s, dtype='S1', count=-1)

# numpy.fromiter(iterable, dtype, count=-1)
# 从可迭代对象中建立 ndarray 对象，返回一维数组
# 参数； - iterable - 可迭代对象,
#       - count: 读取的数据数量，默认为-1，读取所有数据
list = range(10)
x = np.fromiter(list, dtype='int', count=-1)

# np.fromfile
# np.fromfunction
# np.fromregex
# np.fromstring

# ###### 从数值范围创建数组

# numpy.arange(start, stop, step, dtype)
# 根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray
arr_arange = np.arange(5)
# print(arr_arange)

# np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的
# 参数； num: 要生成的等步长的样本数量，默认为50
#       endpoint: 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True
#       retstep: 如果为 True 时，生成的数组中会显示间距，反之不显示
arr_linspace = np.linspace(
    10, 1000, num=30, endpoint=True, retstep=2, dtype='int')
# print(arr_linspace)

# ==================================================================================
# Ndarray 对象 - 切片和索引
# ==================================================================================

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

# ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，
# 并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组
arr_forslice = np.arange(0, 120, 2, dtype='int')
slice = slice(2, 7, 2)
arr_forslice_aftersliced = arr_forslice[slice]
# print(arr_forslice_aftersliced)


# #######高级索引

# 除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引

# 整数数组索引

# 以下实例获取数组中(0,0)，(1,1)和(2,0)位置处的元素
arr_ad_int_index = np.array([[1, 2], [3, 4], [5, 6]])
y = arr_ad_int_index[[0, 1, 2], [0, 1, 0]]

# 以下实例获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]
x = np.array([
    [0,  1,  2],
    [3,  4,  5],
    [6,  7,  8],
    [9,  10,  11]])
# [0 0 3 3] - [0 2 0 2]=[0,0],[0,2],[3,0],[3,2]
rows = np.array([[0, 0], [3, 3]])
cols = np.array([[0, 2], [0, 2]])
y = x[rows, cols]

# ##布尔索引

# 通过一个布尔数组来索引目标数组
# 尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组
# 返回值是符合条件的元素组成的 numpy 数组
arr_bool_index = np.array(
    [[0,  1,  2], [3,  4,  5], [6,  7,  8], [9,  10,  11]])
print(arr_bool_index[arr_bool_index != 5])
print(arr_bool_index[arr_bool_index == 5])
print(arr_bool_index[arr_bool_index >= 5])
print(arr_bool_index[arr_bool_index <= 5])
print(arr_bool_index[~arr_bool_index <= 5])

# ##花式索引 - 花式索引指的是利用整数数组进行索引

# 花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。
# 对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；
# 如果目标是二维数组，那么就是对应下标的行

# 花式索引跟切片不一样，它总是将数据复制到新数组中。
x = np.arange(32).reshape((8, 4))
x1 = np.arange(32)
print(x1)
print(x1[[4, 2, 1, 7]])
print(x[[4, 2, 1, 7]])  # 取 从 0 开始，索引为 4 的行，为 2 的行， 为 1 的行， 为 7 的行 并组成新的数组

# 传入多个索引数组(np.ix_) - 返回值看不懂， 第二个参数貌似没起作用
tem = x[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]

# ==================================================================================
# 广播(Broadcast)
# ==================================================================================

# 广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式，
# 对数组的算术运算通常在相应的元素上进行。 - 尤其是对于 数组形状(shape 属性)不相同的情形

# ==========
# 广播规则
# =========

# 1.让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐
# 2. 输出数组的形状是输入数组形状的各个维度上的最大值
# 3. 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错
# 4. 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值
#  对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足
#  数组拥有相同形状
#  当前维度的值相等
#  当前维度的值有一个是 1
# 若条件不满足，抛出 "ValueError: frames are not aligned" 异常


# 当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制
a = np.array([[0, 0, 0],
              [10, 10, 10],
              [20, 20, 20],
              [30, 30, 30]])
b = np.array([1, 2, 3])
print(a + b)
# ---------
# [[1  2  3]
#  [11 12 13]
#  [21 22 23]
#  [31 32 33]]