python数值计算numpy

python数值计算numpy

import numpy as np
#numpy中生成数组的方法
#方法1.no.array():参数为列表
# lis1=[[1,2,3],[4,5,6]]
# print(lis1)#[[1, 2, 3], [4, 5, 6]]
# array1=np.array(lis1).reshape(6,1)#reshape决定数组规格
# print(array1)
# '''结果:[1 2 3]
#  [4 5 6]]'''
# #数组转化为列表
# lis2=array1.tolist()
# print(lis2)#[[1, 2, 3], [4, 5, 6]]
#方法2.np.ndarray(argv1).reshape(argv2):argv1为元素总数，argv2为规格,数组里的元素都是随机的
# array2=np.ndarray(6).reshape(2,3)
# print(array2)
#方法3.np.arrange().reshape():arrange与range用法类似
# array3=np.arange(1,10,2).reshape(5,1)
# print(array3)

#numpy中查看数组的一些属性
import numpy as np
lis1=[[1,3,9],[2,10,0],[1,99,20],[12,13,15]]
array1=np.array(lis1)
print(array1)#生成数组
#1.查看数组规格
print(array1.shape)#(4, 3)
print(np.shape(array1))#(4, 3)
#2.查看数组维度
print(array1.ndim)#2
print(np.ndim(array1))#2
#3.查看数组长度
print(array1.size)#12
print(np.size(array1,axis=0))#4
print(np.size(array1,axis=1))#3

import numpy as np
#生成特殊数组
#1.生成全零数组
array1=np.zeros([3,3])
print(array1)
"""[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]"""
#2.生成全1数组
array2=np.ones([4,2])
print(array2)
"""[[1. 1.]
 [1. 1.]
 [1. 1.]
 [1. 1.]]"""
#3.空数组:跟随或随机
array3=np.empty([2,3])
print(array3)
"""[[1. 1.]
 [1. 1.]
 [1. 1.]
 [1. 1.]]"""
array4=np.empty([2,3])
print(array4)
"""[[0. 0. 0.]
 [0. 0. 0.]]"""

import numpy as np
lis1=[[1,3,9],[2,10,0],[1,99,20],[12,13,15]]
array1=np.array(lis1)
print(array1)
#1.enumerate():枚举函数，同时返回序列元素的索引与元素值
# for i,k in enumerate(array1):
#     print(i,"-->>",k)
# """ 0 -->> [1 3 9]
#     1 -->> [ 2 10  0]
#     2 -->> [ 1 99 20]
#     3 -->> [12 13 15]"""
# for i in array1:
#     print(i)
# """ [1 3 9]
#     [ 2 10  0]
#     [ 1 99 20]
#     [12 13 15]"""
#2.获取最大值索引
# print(np.argmax(array1,axis=1))
#axis缺省,所有元素中最大的索引#7
#axis=0,每一列最大元素索引#[3 2 2]
#axis=1,每一行最大元素索引#[2 1 1 2]
#3.获取最小值索引
# print(np.argmin(array1,axis=1))
#axis缺省,所有元素中最小的索引#5
#axis=0,每一列最大元素索引#[0 0 1]
#axis=1,每一行最大元素索引#[0 2 0 0]
#4.获取最大值
# print(np.max(array1,axis=1))
#axis缺省,所有元素中最大值#99
#axis=0,每一列最大值#[12 99 20]
#axis=1,每一行最大值#[ 9 10 99 15]
#5.获取最小值
# print(np.min(array1,axis=1))
#axis缺省,所有元素中最小值#0
#axis=0,每一列最小值#[1 3 0]
#axis=1,每一行最小值#[ 1  0  1 12]

import numpy as np
#关于numpy中数组array中axis轴的理解
lis1=[[[0,1,2,3],[91,8,7,6]],[[0,0,100,0],[9,9,9,9]]]
array1=np.array(lis1)
print(array1)
"""[[[  0   1   2   3]#000-003
  [ 91   8   7   6]]#010-013
 [[  0   0 100   0]#100-103
  [  9   9   9   9]]]#110-113"""
print("-------------------------------")
# print(array1.shape)#(2, 2, 4)
print(np.max(array1,axis=0))#从0xx与1xx中找最大
"""[[  0   1 100   3]
 [ 91   9   9   9]]"""
# print(np.max(array1,axis=1))#从x0x与x1x中找最大
"""[[ 91   8   7   6]
 [  9   9 100   9]]"""
# print(np.max(array1,axis=2))#从xx0,xx1,xx2,xx3中找最大
"""[[  3  91]
 [100   9]]"""

import numpy as np
#numpy中数组运算(广播机制)
"""Numpy的Universal functions 中要求输入的数组shape是一致的，
   当数组的shape不想等的时候，则会使用广播机制，调整数组使得shape一样，
   满足规则，则可以运算，否则就出错。
"""
"""四条规则如下：
1. 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
2. 输出数组的shape是输入数组shape的各个轴上的最大值
3. 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错
4. 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值
"""
#1.单个元素广播：
a=np.arange(6).reshape(3,2)
# b=[100]
print(a)
"""[[0 1]
   [2 3]
   [4 5]]"""
# print(a+b)
"""[[100 101]
   [102 103]
   [104 105]]"""
#2.有一个维度相同
# b=[1,2]
# print(a+b)
"""[[1 3]
 [3 5]
 [5 7]]"""
# b=[[1],[2],[3]]
# print(a+b)
"""[[1 2]
   [4 5]
   [7 8]]"""
#3.若一个维度都不同则会报错
# b=[1,2,3]
# print(a+b)#ValueError: operands could not be broadcast together with shapes (3,2) (3,)

import numpy as np
# array1=np.arange(6).reshape(3,2)
# print(array1)
"""[[0 1]
 [2 3]
 [4 5]]"""
#1.np.sqrt(array2):对数组array2中每个元素求平方根
# array2=np.sqrt(array1)
# print(array2)
"""[[0.         1.        ]
 [1.41421356 1.73205081]
 [2.         2.23606798]]
"""
#2.array.T:矩阵转置
# print(array1.T)
"""[[0 2 4]
 [1 3 5]]"""
#3.np.transpose(array,[]):按规定要求进行转置,array为数组,[]为要求
array1=np.arange(24).reshape(3,4,2)
print(array1.shape)#(3, 4, 2)
array2=np.transpose(array1)
print(array2.shape)#(2, 4, 3)
array3=np.transpose(array1,[1,2,0])
print(array3.shape)#(4, 2, 3)
array4=np.transpose(array1,[0,2,1])
print(array4.shape)#(3, 2, 

import numpy as np
#1.python 数组求和:numpy.sum(array,axis):array为所要求和的数组名,axis为求和轴数
array1=np.arange(24).reshape(3,2,4)
# print(array1)
"""[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]

 [[16 17 18 19]
  [20 21 22 23]]]"""
# sum1=np.sum(array1)
# print("sum1:",sum1)#axis缺省,所有元素求和:276
# sum2=np.sum(array1,axis=0)
# print("sum2:",sum2)
#axis=0,第零轴各元素求和
#求和后为shape为(2,4)数组,对应位置xx元素为0xx,1xx,2xx求和
"""[[24 27 30 33]
 [36 39 42 45]]
"""
# sum3=np.sum(array1,axis=1)
# print("sum3:",sum3)
#axis=1,第一轴各元素求和
#求和后为shape为(3,4)的数组,对应位置xx元素为x0x,x1x求和
"""[[ 4  6  8 10]
 [20 22 24 26]
 [36 38 40 42]]"""
# sum4=np.sum(array1,axis=2)
# print("sum4:",sum4)
"""[[ 6 22]
 [38 54]
 [70 86]]"""
#axis=2,第二轴各元素求和
#求和后为shape为(3,2)的数组,对应位置xx元素为xx0,xx1,xx2,xx3求和
#2.python中两个矩阵相乘:np.dot(array1,array2),array1与array2为相乘的两数组
# array1=np.arange(6).reshape(2,3)
# array2=np.arange(6).reshape(3,2)
# array3=np.dot(array1,array2)
# print(array1)
"""[[0 1 2]
 [3 4 5]]"""
# print(array2)
"""[[0 1]
 [2 3]
 [4 5]]"""
# print(array3)
"""[[10 13]
 [28 40]]"""

import numpy as np
#numpy中有关随机数的操作:numpy.random
#1. np.random.randint(start,end,size):start为起始,end为结尾范围.size为大小
# array1=np.random.randint(0,10,12)
# print(array1)#[2 9 8 0 9 1 9 1 9 9 3 9]
# array2=np.random.randint(0,10,[2,3])
# print(array2)
"""[[9 1 8]
 [0 8 8]]
"""
#2.生成均匀分布
#(1)np.random.rand(size):生成从0到1的均匀分布
# array1=np.random.rand(10)
# print(array1)
# """[0.55313043 0.29733838 0.26187328 0.05672451 0.22809421 0.21937224
#  0.22868325 0.65228393 0.21022562 0.48382864]"""
# array2=np.random.rand(2,2)
# print(array2)
"""[[0.58066955 0.68700158]
 [0.16734161 0.59596258]]"""
#(2)np.random.random(size):生成从0到1的均匀分布
# array1=np.random.random(5)
# print(array1)#[0.84064002 0.18590337 0.77024641 0.20079054 0.38686075]
# array2=np.random.random([2,2,2])
# print(array2)
"""[[[0.63641789 0.80927149]
  [0.21048293 0.13961108]]

 [[0.19714377 0.29393692]
  [0.04100226 0.2921725 ]]]
"""
#(3)np.random.ranf(size):0到1之间的均匀分布
# array1=np.random.ranf(3)
# print(array1)#[0.48119275 0.89201233 0.72447006]
# array2=np.random.ranf([2,2,2])
# print(array2)
"""[[[0.83072489 0.86193294]
  [0.46729619 0.35722625]]

 [[0.62861038 0.44320955]
  [0.71453335 0.3454169 ]]]"""
#(4)np.random.uniform(a,b,size):生成指定范围的均匀分布
# array1=np.random.uniform(2,3,[3])
# print(array1)#2.19385467 2.17226387 2.05153733]
#3.生成正态分布
#(1)np.random.randn(size):生成标准正态分布
# array1=np.random.randn(3)#注意参数不能为列表
# print(array1)#[-0.94941758  0.38245363 -0.63467765]
#(2)np.random.normal(a,b,size):a为均值,b为方差,size为数组形状
array1=np.random.normal(3,1,[2,2])
print(array1)
"""[[3.04052738 3.95125473]
 [4.52659015 4.59500147]]"""
array2=np.random.normal(2,8,[2,2])
print(array2)
"""[[ -6.80339522  -7.08122286]
 [ -5.26583224 -11.70895615]]"""

#python切片array[a,b,c,.....]:a,b,c分别代表0,1,2.....轴切片,切片后结果轴不变
import numpy as np
# array1=np.arange(24).reshape(2,3,4)
# print(array1)
"""[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]"""
# array2=array1[:1,:2:,3:]
# print(array2)
"""[[[3]
  [7]]]"""
# array3=array1[1:,1:,1:3]
# print(array3)
"""[[[17 18]
  [21 22]]]"""
#python数组复制的几种方法及其区别
# array1=np.arange(6).reshape(2,3)
# array2=array1#直接复制
# array3=array1[:,:]#切片复制
# array4=array1.copy()#借助copy()函数复制
# print("改变前:---------------")
# print("array1:",array1)
# print("array2::",array2)
# print("array3:",array3)
# print("array4:",array4)
# array1[0,0]=1000
# print("改变后:---------------")
# print("array1:",array1)
# print("array2::",array2)
# print("array3:",array3)
# print("array4:",array4)
# print(array2 is array1)
# print(array3 is array1)
# print(array4 is array1)
"""改变前:---------------
array1: [[0 1 2]
 [3 4 5]]
array2:: [[0 1 2]
 [3 4 5]]
array3: [[0 1 2]
 [3 4 5]]
array4: [[0 1 2]
 [3 4 5]]
改变后:---------------
array1: [[1000    1    2]
 [   3    4    5]]
array2:: [[1000    1    2]
 [   3    4    5]]
array3: [[1000    1    2]
 [   3    4    5]]
array4: [[0 1 2]
 [3 4 5]]
True
False
False"""
#使用copy复制后两数组无关联,另两种复制后与原数组发生同步变化
#is结果返回True需满足:1.两变量值相同,2.两变量地址相同

#python中矩阵拼接
#np.vstack((array1,array2)):垂直拼接,矩阵的shape需相同
array1=np.arange(6).reshape(2,3)
print(array1)
# """[[0 1 2]
#  [3 4 5]]"""
array2=np.arange(6).reshape(2,3)
print(array2)
# """[[0 1 2]
#  [3 4 5]]"""
# array3=np.vstack((array1,array2))
# print(array3)
"""[[0 1 2]
 [3 4 5]
 [0 1 2]
 [3 4 5]]
"""
#np.hstack((array1,array2)):水平拼接
array4=np.hstack((array1,array2))
print(array4)
"""[[0 1 2 0 1 2]
 [3 4 5 3 4 5]]"""