python-numpy

import numpy as np
#np.array 将Python序列转化为数组
# list1 = [1,2,3,4]
# np.array(list1)  # array([1, 2, 3, 4])
list2 = [[1,2,3,4],[5,6,7,8]]
np.array(list2)  
#array([[1, 2, 3, 4],
#        [5, 6, 7, 8]])
list1=[
    [11,21,31,41],
    [5,6,7,8],
    [100,100,100,100]
]
arr1=np.array(list1)
arr1
arr1.mean()

tup1=(1,2,3,4,5)
np.array(tup1)

tup2 = (
    (1,2,3,4),
    (5,6,7,8)
)
np.array(tup2)

#创建指定长度或者形状的全零数组
np.zeros(3)
np.zeros((4,8))

#创建指定长度或者形状的全1数组
np.ones((3,9))

创建一个没有任何具体值的数组(准确地说是创建一些未初始化的ndarray多维数组)
np.empty(9)
np.empty([9,9])

#类似python的range函数，通过指定开始值、终值和步长来创建一个一维数组，注意：最终创建的数组不包含终值
np.arange(20)
np.arange(10,20)

np.arange(10,30,4)

np.arange(20,4,-4)

#通过指定开始值、终值和元素个数来创建一个一维数组，数组的数据元素符合等差数列，可以通过endpoint关键字指定是否包含终值，默认包含终值
np.linspace(0,10,5)

np.logspace(0,10,10) #等比数列数组

#使用随机数填充数组，即使用numpy.random中的random()函数来创建0-1之间的随机元素，数组包含的元素数量由参数决定
np.random.random((3,2,3))

np.random.rand(9)  #返回零到一的随机数

np.random.randn(3,3)  #标准正太分布

a=np.random.randint(1,9,size=(3,3))
a

a.ndim  #数组轴(维度)的个数，轴的个数被称作秩 

a.shape  #数组的维度

a.dtype  #一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型

a.size  #数组元素的总个数

a.itemsize  # itemsize 每个元素的字节大小

a2 = np.array([1,2,3,4])
print(a2)
a3 = a2.astype(float)   #类型转换要求支持类型的转换
a3.dtype

arr = np.random.randint(36,size=(3,12))
arr

arr2 = arr[:,1:3,1:3]

# dtype  数据类型
# socres = np.random.randint(0,101,[1000,8])
# socres.dtype
scores=[np.random.randint(0,100) for i in range(1000)]
scores
arr6 = np.array(scores,dtype="i8")   #可以在创建得时候指定数据类型
arr6.dtype
arr7 = arr6.astype("int32")  #通过astype复制数组设定新的数据
arr7.dtype

arr1 = np.random.randint(0,101,[3,4])
arr1
arr1.shape=(2,6)
arr1
#reshape 修改形状赋值给一个新的数组， 
# -1 代表自动计算 
arr2 = arr1.reshape(4,-1)
arr2
arr3 = arr2.reshape(-1)
arr3

#数值运算，矢量化运算
# money = np.random.randint(4000,30000,35)
print(money)
money-1000
money*2
money>10000
# 元素级操作，如果两个数组的形状相同，那么会是对应位置运算
data=np.array([
    -1000,-1000,-1000,-1000,1000,-1000,-1000,-1000,
    -1000,1000,-1000,-1000,-1000,-1000,1000,-1000,-1000,
    -1000,-1000,1000,-1000,-1000,-1000,-1000,1000,-1000,
    -1000,-1000,-1000,1000,-1000,-1000,-1000,-1000,1000])
data.size
money+data

#数组广播  限定条件  shape 值对应位置  要么相同，要么为1
money = money.reshape(5,-1)
print(money)
data=np.array([
    [1000],
    [2000],
    [3000],
    [4000],
    [5000]
])
data.shape
data = np.array([[50000,0,0,0,0,0,0]])
money+data
score = np.random.randint(0,101,[4,6])
score
data = np.random.randint(0,10,[2,3])
data+score

#nums每行代表每个部门，每列代表不同的产品
nums= np.array([
    [120,60,220],
    [115,23,201],
    [132,48,230]
])
#data 每行代表不同的产品，每列代表产品的单价和体积
data=np.array([
    [12.34,0.04],
    [204.56,2.34],
    [9.89,0.45]
])
# 每个部门的所有产品的利润和需要的空间
np.dot(nums,data)

# 一维数组索引
# arr1=np.array([9,3,82,31,45])
# arr1[2]
# arr1[-1]
#二维数组索引
# arr2 = np.array([
#     [100,20,38],
#     [30,10,22],
#     [3,3,3]  
# ])
# print(arr2[1])
# print(arr2[2][2])
#numpy自带的索引方式，每个维度用逗号隔开
# print(arr2[2,2])
# print(arr2[1,0])
#切片操作
arr3 = np.arange(36).reshape(6,6)
print(arr3)
#获取1,3,4行
# print(arr3[0:3:2])
#获取第一列和最后一列
# arr_view = arr3[:,[0,-1]]
# arr_view

# 花式索引  
#获取第1,3,行的2,4列
# print(arr3[[0,2],[1,3]])   #不对的方式
# arr3[[0,2]][:,[1,3]]  #先取行，然后在切所有的行的指定列
# arr3[[0,2]].T[[1,3]].T   #先取行，转置再取行，再转回来
# np.ix_()  #索引器
# arr3[np.ix_([0,2],[1,3])]

#布尔索引
#想要数组中的偶数
# condition=arr3%2==0
# print(condition)
# arr3[condition]

#数组中值大于20并且是偶数的  & and  |  or 
# arr3[(arr3%2==0) & (arr3>20)]

#数组中能被5整除  或者除以3余1的数
arr3[(arr3%5==0) |(arr3%3==1)]

#可以按照行列的方式放布尔索引
arr3[[True,False,True,False,False,False],[False,True,False,False,False,False]]

arr3 = np.arange(1,11).reshape(2,5)
arr3
#数组的转置  T 转置
arr3.T

arr4=np.arange(24).reshape(2,3,4)
print(arr4)
arr4.T

# transpose()
arr4.transpose()   #默认是转置操作  也就是  2   1   0
arr4.transpose(1,2,0)  #制定换成  1  2  0    3个4行2列的数组

# np.tile(arr,rep)  #数组的拉伸rep拉伸倍数
scores = np.random.randint(0,101,[5,3])
# print(scores)
# np.tile(scores,2)  #横向拉伸两倍
# np.tile(scores,[2,1]) #横向拉伸1倍，纵向拉伸2倍
# np.tile(scores,[2,2])
scores2=np.random.randint(0,101,[9,3])
# print(scores2)

#数组的合并  stack()  vstack()  hstack()
arr5 = np.vstack([scores,scores2])  #垂直堆叠  两个数组垂直合并
arr5
scores_subject3=np.random.randint(0,101,[14,3])
np.hstack([arr5,scores_subject3])  #水平堆叠

#stack() 沿着不同的轴添加新的元素
a1 = np.ones(3)
a2 = np.zeros(3)
np.stack([a1,a2],axis=1)
a3 = np.arange(32).reshape(4,8)
a4 = np.zeros([4,8])
np.stack([a3,a4],axis=0)
np.stack([a3,a4],axis=1)
np.stack([a3,a4],axis=2)

# np.abs()  fabs()  对数值元素进行一个绝对值的运算 fabs() 更快的速度,但是不能计算 复数a+bj 的绝对值
# arr2=np.random.randint(-100,100,[10,10])
# print(arr2)
# np.abs(arr2)

# sqrt() 平方根
# np.sqrt(arr2)
# arr2**0.5

# square() 平方
# np.square(arr2)
# arr2**2

# exp() 计算自然常数e的x次方
# arr=np.array([0,1,5,2,10,2.71828183,1.71828183,100,25,100])
# print(arr)
# np.exp(arr)

# log() log10()  log2()  log1p() 
# np.log(arr) # 以e为底 arr为真数,求对数
# np.log10(arr)
# np.log2(arr)
# np.log1p(arr) # 以e为底,1+arr 为真数,求对数
# np.log2(arr)/np.log2(5) # 想要得到任意数为底数,使用换底公式就可以了


# sign() 计算元素的正负号, 正数返回 1 负数返回 -1  0 返回0 
# np.sign(arr2)

# np.ceil() 向上取整  np.floor() 向下取整
arr5=np.array([1.9999,1.00001,2.1,3,5.00000009,1.5333,2.5414,3.5,4.5])
# print(arr5)
# np.ceil(arr5)
# np.floor(arr5)


# np.rint() 四舍六入五成双 
# np.rint(arr5)
# np.round(arr5,decimals=2) # decimals 保留有效位数


# np.modf() 讲小数位和整数位分成两个数组返回,合并到一个元组中
# np.modf(arr5)

# np.isnan() 判断是否是 异常数值 nan
# res1=arr2**0.5
# res1[np.isnan(res1)]=0 # 异常值替换
# res1

# np.isfinite() 是否是有穷的(非nan,非inf),  np.isinf() 是否是无穷的(inf)
# arr6=np.array([1,2,3,np.nan,90,131,5,np.inf,np.inf])
# print(arr6)
# np.isfinite(arr6) 
# np.isinf(arr6)


# cos sin tan 三角函数  cosh tanh sinh 双曲型三角函数
x=np.arange(-3,4,0.2)
y=np.sin(x)
# y1=np.cos(x)
import matplotlib.pyplot as plt
plt.plot(x,y)
# plt.plot(x,y1)
plt.show()

# arccos arcsin arctan 反三角函数  arccosh arcsinh arctanh 反双曲型三角函数

# mod
x=np.arange(9)
print(x)
y=np.random.randint(1,4,9)
print(y)
# np.mod(x,3)
# np.mod(x,y)
# x%y

# np.dot()  矩阵积

# np.greater   greater_equal  less  less_equal  equal  not_equal
# np.greater(x,y)
# np.greater_equal(x,y)
# x>=y


# logical_and   or xor 
arrx=np.array([True,False,False,True,True,True,False])
arry=np.array([True,True,False,False,True,False,False])
# np.logical_and(arrx,arry)
# np.logical_or(arrx,arry)
# np.logical_xor(arrx,arry) # 异或,一边True,一边False 为True,否则都为False


# np.power() 幂运算
# np.power(x,y)
# x**y

# max() 最大值 min() 最小值 mean() 均值
# infos=np.random.randint(0,101,[20,6])
# print(infos)
# 总体聚合
# np.max(infos)
# np.min(infos)
# np.mean(infos)
# 每个人的平均分,或者是每个科目的平均分
# np.mean(infos,axis=0) #每列的平均分
# np.mean(infos,axis=1) # 每行的平均分

#  var 方差   std 标准差
# ((x-x平均值)的平方)均值
# np.mean(np.square(infos-np.mean(infos))) # 方差981.963263888889
# np.sqrt(np.mean(np.square(infos-np.mean(infos))))  # 标准差31.336293078296432
# np.var(infos)#981.963263888889
# np.std(infos)#31.336293078296432

# np.where() 可以查询满足条件的位置,也可以从两个数组里返回满足条件的值
# position=np.where(infos>60) # 返回True对应的索引位置,分为两个数组
# infos[position]

# np.where(condition,x,y) 第二个参数是 condition 为True的时候取对应的值,第三个参数是为False的时候取对应的值
# x=np.random.randint(0,10,10)
# y=np.random.randint(0,10,10)
# print(x,y,sep="\n")
# np.where(x>y,x,y)  #

# 把异常值替换为 0
# x=np.array([1,8,2,51,6,np.nan,np.nan,48,64,np.inf])
# np.where(np.isfinite(x),x,0)

# money=np.random.randint(4000,20000,[6,3])
# print(money)
# np.where(money>10000,money+1000,money-1000)

y=np.random.randint(0,10,[100,10])
y
np.unique(y) # 去重