# 导入numpy模块并起别名为np
import numpy as np

# 显示当前numpy的版本号
print(np.__version__)

# 0.数组的概念
'''
数组是一个容器，它可以存放一定数量的元素，这些元素类型相同。
'''

# 1.创建一维数组
arr1 = np.array([1, 2, 3, 4])

print("创建数组：", arr1)

# 2.创建二维数组
'''
二维数组就是以数组作为数组元素的数组，通俗点说就是数组里面全是数组的数组。
'''
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print("二维数组:\n", arr2)

# 3.数组的属性
'''
ndim      数组的维度(数组嵌套的层数) 
shape     数组的形状(n,m) n行m列
size      数组的数量
dtype     数组元素的类型
itemsize  数组每个元素的大小
'''

print("数组的维度:", arr2.ndim)
print("数组的形状:", arr2.shape)
print("数组的数量", arr2.size)
print("数组元素的类型", arr2.dtype)
print("数组每个元素的大小", arr2.itemsize)

# 4.其他方式创建数组
'''
np.arange(start,end,step,dtype) 创建范围内的数组
start 起始值
end   结束值
step  步长值
dtype 数据类型
'''
arr3 = np.arange(-3, 3, 0.5)

print("np.arange(-3, 3, 0.5):", arr3)

'''
等差数列函数
linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None,
             axis=0):
num 生成的数据量，默认50
endpoint 值为True是包含stop值，否则不包含，默认为True
retstep  值为True时显示数据间距
dtype    ndarry数组的类型
'''
print("等差数列：\n", np.linspace(0, 2 * np.pi, num=10, retstep=True))

'''
等比数列
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None,
             axis=0):
start (base ** start)
end   (base ** end)             
base:对数log的底数
'''
print("等比数列：", np.logspace(1.0, 4.0, num=50, base=2))

'''
创建指定形状的未初始化数组
np.empty(shape, dtype=None)
'''

print("empty:", np.empty((3, 3, 2)))

'''
创建指定形状的全0数组
np.zeros(shape, dtype=None)
'''
print('zeros:', np.zeros((3, 3)))

'''
创建指定形状的全1数组
np.ones(shape, dtype=None)
'''

print('ones', np.ones((2, 3)))

'''
单位矩阵，即对角线元素为1，其余为0
np.eye(N, M=None, k=0, dtype=float)
'''
print('eye创建单位矩阵：\n', np.eye(3))

'''
将以为数组转换为方阵(对角线为原一维数组，其余为0)
diag(v, k=0)
'''
print(np.diag(np.arange(1, 10)))

# 5.打印数组
'''
一维数组显示为列表
二维数组显示为矩阵
三维刷组显示为矩阵的列表
'''
a = np.arange(10)
print("a:", a)

# reshape() 转换维度
b = np.arange(12).reshape(3, 4)
print("b:\n", b)

c = np.arange(24).reshape(2, 3, 4)
print("c:\n", c)

# 6.数组的常用数据类型
'''
int8     uint8
int16    uint16
int32    uint32
int64    uint64
float16
float32
float64
float128
bool

object 
string
unicode
'''

arr4 = np.arange(1, 20, dtype=np.float32)
print(arr4, arr4.dtype)

# 类型转换
print(np.float32(10))
print(np.int8(2.12))

# 7.随机数
'''
np.random.random   随机小数
np.random.randint  随机范围内的整数
np.random.rand     均匀分布 指定形状
np.random.randn    正态分布（均值分布最多，两侧分布递减） 指定形状
'''

print(np.random.rand(2, 3))
print(np.random.randn(2, 3))

# 8.切片
'''
和列表索引相同
'''
arr5 = np.arange(1, 10)

print(arr5[1:8:2])

# 9.多维数组索引
'''
多维索引的每个数组维度都有一个索引，每个维度的索引之间使用逗号分隔
'''
arr6 = np.arange(16).reshape(4, 4)

print(arr6)
print(arr6[0, 0])
print(arr6[2, :2])
# 高级索引
print(arr6[(1, 2, 3), (0, 1, 2)])
print(arr6[arr6 > 10])

import numpy as np

# 1.修改数组的形状
'''
reshape 不改变数组的条件下改变形状
flat    数组元素迭代器
flatten 返回一个数组拷贝，对拷贝所做的修改不会影响原始数组
ravel   返回展开的数组
'''

'''
np.ndarry.reshape(arr,newshape,order='C')
arr      需要修改的数组
newshape 新的形状
order    'C'--按行 'F'--按列  'A'--原顺序 'k'--元素在内存中的顺序
'''

arr1 = np.arange(12).reshape(2, 6)
print(arr1)
print('维度:', arr1.ndim)
print('形状:', arr1.shape)

arr2 = np.arange(12).reshape(2, 2, 3)
print(arr2)
print('维度:', arr2.ndim)
print('形状:', arr2.shape)

# -1表示当一个轴数确定后，自动计算的另一个咒术
arr3 = np.arange(12).reshape(-1, 4)
print(arr3)
print('维度:', arr3.ndim)
print('形状:', arr3.shape)

arr4 = np.arange(12).reshape(3, -1)
print(arr4)
print('维度:', arr4.ndim)
print('形状:', arr4.shape)

print(arr3 == arr4)

'''
ravel(arr,order='C')
order    'C'--按行 'F'--按列  'A'--原顺序 'k'--元素在内存中的顺序

'''
print(arr4.ravel())
print(arr4.ravel('F'))

'''
flatten 与reavel函数类似，但变形后不影响原数组
'''

print(arr4.flatten())

'''
flat迭代数组元素
一维数组和列表迭代方法一致
'''
arr5 = np.arange(12)
for i in arr5:
    print(i)

arr6 = arr5.reshape(3, 4)
print(arr6)
for item in arr6.flat:
    print(item)

'''
np.transpose(arr) 转置操作将原来的行变列，原来的列变行
'''

print(np.transpose(arr6))

'''
np.ndarry.T  一二维转置
'''

print(arr6.T)

# 2.连接数组
'''
np.concatenate 连接两个数组，axis=0纵向组合，axis=1横向组合
np.hstack 横向组合
np.vstack 纵向组合
'''

arr7 = np.arange(6).reshape(2, 3)
arr8 = np.arange(6, 12).reshape(2, 3)
# print(arr7, arr8)
# vstack纵向组合
print(np.vstack((arr7, arr8)))
# hatack横向组合
print(np.hstack((arr7, arr8)))
# 相当于vstack纵向组合
print(np.concatenate((arr7, arr8), axis=0))
# 相当于hatack横向组合
print(np.concatenate((arr7, arr8), axis=1))

# 3.切割数组
'''
np.hsplit() 纵向切割
np.vsplit() 横向切割
np.split(axis=0)  横向切割
np.split(axis=1)  纵向切割
'''
arr9 = np.arange(16).reshape(4, 4)
arr10 = np.hsplit(arr9, 2)
print(arr10)
print(arr10[0])
print(arr10[0].shape)
arr11 = np.vsplit(arr9, 2)
print(arr11)
print(arr11[0])
print(arr11[0].shape)

print(np.split(arr9, 2, axis=0))
print(np.split(arr9, 2, axis=1))

# 4.删除维度
'''
np.squeeze(arr,axis)
删除1维的维度
'''

arr12 = np.arange(10).reshape(1, 2, 5)

print(arr12, arr12.shape)
arr13 = np.squeeze(arr12)
print(arr13, arr13.shape)

# 5.数组运算

x = np.array([1, 2, 3, 4])
y = np.array([5, 6, 7, 8])

print('数组相加：', x + y)
print('数组相减：', x - y)
print('数组相乘：', x * y)
print('数组相除：', x / y)
print('数组幂运算：', x ** y)

print(x > y)  # [False False False False]
print(x < y)  # [ True  True  True  True]
print(x == y)  # [False False False False]
print(x <= y)  # [ True  True  True  True]
print(x >= y)  # [False False False False]

'''
np.all()  表示逻辑and
np.any()  表示逻辑or
'''
x = np.array([1, 2, 2])
y = np.array([2, 2, 3])

print(np.all(x == y))  # False
print(np.any(x == y))  # True

'''
* 对应位置元素相乘
np.dot 矩阵乘积
'''

print(x * y)
print(np.dot(x, y))

# 6.numpy广播
'''
两个数组维度形状相同时，a*b则对应位置相乘。
如果维度形状不同则触发广播机制。
'''
x = np.arange(10).reshape(5, 2)

y = np.array([1, 2])

print(x + y)

'''
[[ 1  3]
 [ 3  5]
 [ 5  7]
 [ 7  9]
 [ 9 11]]
'''
print(x * y)
'''
[[ 0  2]
 [ 2  6]
 [ 4 10]
 [ 6 14]
 [ 8 18]]
'''