numpy知识点概括

#导入numpy

import numpy as np
import random

#创建随机数

 #一维数组：
    a=np.random.random(size=5)#生成五个0-1之间的随机数
    #二维数组：
    b=np.random.random(size=(3,4))#生成三行四列0-1之间的随机数
    #三维数组：
    c=np.random.random(size=(2,3,4))#生成两个三行四列的0-1之间的随机数

#创建随机整数：

#np.random.randint(low,high=None,size=None,dtype='1')
    #生成0-5之间的10个一维随机整数：
    a=np.random.randint(6,size=10)
    #生成5-10之间的四行三列随机整数：
    b=np.random.randint(5,11,size=(4,3))
    #生成5-10随机整数  三维
    c=np.random.randint(5,10,size=(2,4,3))
    #dtype的使用：
    d=np.random.randint(10,size=5,dtype=np.int64)
    print('默认的dtyoe',d.dtype)

#正态分布：
#创建标准的正态分布 期望为0 方差为1

    #一维：
   a=np.random.randn(4)
    #二维：
    b=random.randn(2,3)
    #三维：
    c=random.randn(2,3,4)

#创建指定期望和方差的正态分布：

 random.normal(loc=0.0,scale=1.0,size=None)  #loc(期望)  scale(方差)



#创建一维的数组：
    a=np.array([1,2,3,4])   #[1 2 3 4]
    b=np.arrange(4,10)   #[4 5 6 7 8 9]
#创建二维的数组：
    b=np.random.randint(4,10,size=(2,3))   #4-10之间的二维随机整数
#创建三维的数组：
    c=np.random.randn(2,3,4)  #三维的标准的正态分布

#ndim属性（维度）：
    print('ndim:',a.ndim,b.ndim,c.ndim)   #ndim:1 2 3  表示维度

#shape（形状）属性：
    print('shape:',a.shape,b.shape,c.shape) #shape:(4,)(2,3)(2,3,4)
#dtype（当前元素的类型）
    #dtype：int32 int32 float64
#size（元素的总个数）：
    #size：4 6 24
#itemsize(每个元素所占的字节):
    #itemsize:4 4 8

#zeros创建指定大小的数组，数组元素以0来填充：


#    numpy.zeros(shape,dtype=float,order='C')  默认dtype='float'

 x=np.zeros(5) #结果为[0. 0. 0. 0. 0.] 五个float型
    y=np.zeros((5,),dtype=int)#设置类型为int  结果为[0 0 0 0 0]
#ones 以0填充：
    z=np.ones(5) #结果为[1. 1. 1. 1. 1.]

#empty

#linspace（创建一个等差的一位数组）：
    #np.linspace(start,stop,num=50(要生成的等长步数的样本数量默认为50),endpoint=True,retstep=False,dtype=None)
    np.linspace(1,10,10)#结果为：[1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
    np.linspace(5,20,5,endpoint=False)#结果为[5. 8. 11. 14. 17.]
    np.linspace(5,20,5,endpoint=True)#结果为[5. 8.75 12.5 16.25 20.]
#logspace(创建一个等比数列)：

***

np.logspace(start（起始值 log**）,stop（结束值log**
与endpoint值有关）,num=50(等步长的样本数量，默认为50),endpoint=True（该值为True时，数列中包含stop值，反之不包含，默认为True）,base=10.0（对数log的底数）,dtype=None（ndarray的数据类型）)

---

#索引：

#创建一维数组：
a=np.arrange(10)        #[0 1 2 3 4 5 6 7 8 9]
print(a)
#正索引访问  索引从0开始 长度-1：
print('索引0处的元素：',a[0])      #0
print('索引5处的元素：',a[5])      #5

#负索引访问 倒数第一个元素为-1：
print('访问最后一个元素：',a[-1])        #9
print('访问倒数第三个元素：',a[-3])       #7

#切片操作： [start:stop:step]

 print(a[:])         #从开始到结尾
    print(a[3:])        #从索引3开始到结尾
    print(a[3:5])       #从索引3开始到结尾索引4[start,stop)结尾
    print(a[1:7:2])     #从索引1开始到索引6，步长是2

    #切片中的负索引操作：
    print(a[::-1])      #反向获取
    print(a[-5:-2])     #[5 6 7]

#对二维数组进行切片操作：
        x=np.arrange(1,13) #[1 2 3 4 5 6 7 8 9 10 11 12]
        a=x.reshape(4,3)    #重新转换x的形状  [[1 2 3]
                            #                [4 5 6]
                            #                [7 8 9]
                            #                [10 11 12]]
        print('数组元素',a)
        print('获取第二行',a[1])
        print('获取第三行第二列',a[2][1])

        #切片的使用： [行进行切片，列进行切片]   [start:stop:step,start:stop:step]
        print(a[:,:])   #获取所有行所有列
        print(a[:,1])   #获取所有行部分列   所有行第二列
        print(a[:,0:2]) #获取所有行部分列   所有行第一，二列
        print(a[::2,:]) #获取奇数行所有列
        print(a[::2,0:2])   #获取奇数行 第一1二列

    #同时获取第三行第二列，第四行第一列:
    print(np.array((a[2,1],a[3,0])))    #创建一个数组
    print(a[(2,3),(1,0)])       #使用坐标 2对1 3对0


#坐标获取：  [行，列]
    #获取第二行第三列的元素：
    print(a[1][2])
    print(a[1,2])

    #同时获取不同行不同列     获取第二行第三列    第三行第一列：
    print(a[1,2],a[2][0])
    print(np.array(a[1,2],a[2][0]))     #使用数组
    #使用坐标解决:
    print(a[(1,2),(2,0)])

    #负索引的使用：
    print('最后一行',a[-1])
    print(('行倒序',a[::-1]))       #[[10 11 12]
                                   #[7 8 9]
                                   #[4 5 6]
                                   #[1 2 3]]
    print('行列倒序',a[::-1,::-1])

#数组的复制：

  a=np.arrange(1,13).reshape((3,4))

    #对a数组进行切片处理，获取第一、二行，第一、二列
    sub_a=a[:2,:2]

    #对sub_a中第一行第一列的值进行修改
    sub_a[0][0]=100

    #通过切片可以获取到新数组，及时赋值给新的变量，但还是原来数组的视图
    #如果对切片数组中元素的值进行修改，会影响原来的数组
    #可以用numpy中的copy方法实现：
    sub_aa=np.copy(a[:2,:2])    #是深拷贝（不会影响原数组的值）
    sub_aa[0,0]=200
    print(sub_aa)
    print(a)

 #修改数组的维度：
 #通过reshape将一维数组修改为二、三维数组：
 # a.reshape(10,11)  将行和列直接传入   a.reshape((10,11)) 将行和列作为元组传入

 #创建一个一维数组
    a=np.arrange(1,25)#1-24
    #将一维修改为二维
    b=a.reshape(3,8)
    b=a.reshape((3,8))
    print(b)
    #将一维修改为三维：
    c=a.reshape((2,3,4))
    print(c)
    #通过np.reshape()进行修改：
    #bb=np.reshape(a,(3,8)) #将一维修改为二维
    bb=np.reshape(a,(4,3,2))#将一维修改为三维
    print(bb)

    #将多维数组修改为一维数组：
    #利用reshape()
    a=bb.reshape(24)#（）内要与bb内的元素数量保持一致
    a=bb.reshape(-1)
    print(a)

    #利用函数：
    #ravel：
    a=bb.ravel()
    print(a)
    #flatten:
    a=bb.flatten()
    print(a)

#数组的拼接：

 #创建两个数组：
    a=np.array([[1,2,3],[4,5,6]])
    b=np.array([[11,12,13],[14,15,16]])
    print(a)
    print(b)
    #hstack（将a,b水平方向首尾连接，形成一个新的数组）:
    r=np.hstack([a,b])
    print(r)

    #vstack(垂直方向)
    r=np.vstack((a,b))#a,b使用元组或者列表都可以
    print(r)

    #concatenate:
    #numpy.concatenate((a1,a2,...),axis)  a1,a2:类型相同的数组，axis:沿着它连接数组的轴默认为0
    print('axis=0 默认情况  垂直方向拼接  相当于vstack')
    np.concatenate((a,b),axis=0)

    #二维数组有两个轴 axis=0    axis=1
    print('axis=1   默认情况    水平方向拼接      相当于hstack')
    r3=np.concatenate((a,b),axis=1)
    print(r3)

    #三维数组有三个轴   axis=0 1 2
    a=np.arange(1,13).reshape(1,2,6)
    print(a,a.shape)
    b=np.arange(101,113).reshape(1,2,6)
    print(b,b.shape)

    #np.concatenate((a,b),axis=)#axis的值决定哪个方向进行拼接

#数组的分割：

 #split分割：
    #numpy.split(ary,indices_or_sections,axis)  #ary:被分割的数组
    #indices_or_sections：如果是一个整数，就该用该数平均切分，如果是一个数组，为沿轴切分的位置
    #axis：默认为0横向切分，为1时，纵向切分

    x=np.arange(1,9)#[1 2 3 4 5 6 7 8]
    a=np.split(x,4)
    print(a)#传递整数，平均分割[array[1,2],array[3,4],array[5,6],array[7,8]]

    r=np.split(x,[4,6])
    print(r)#   [array[1,2,3,4],array[5,6],array[7,8]]

    #二维数组进行分割：
    a=np.array[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]

    #axis=0垂直分割，axis=1水平分割

    r,w=np.split(a,2,axis=0)#垂直方向平均分割成两段
    r,w,k=np.split(a,[2,3],axis=0)#垂直方向按位置分割为三段

    #使用hsplit():按水平方向分割，不需要传axis
    r,w=np.hsplit(a,2)#平均分割成两部分

    r,w=np.hsplit(a,[2])#将前两列分割成一部分，后面的分割成一部分
    #使用vsplit
    r,w=np.vsplit(a,2)#垂直平均分割
    r,w=np.vsplit(a,[2])#位置分割

#数组的转置:

  #创建二维数组：
    a=np.arange(1,25.reshape(8,3))

    #使用transpose函数进行数组转置a[i][j]--a[j][i]
    b=a.transpose()#b为a的转置数组
    #使用.T进行转置
    print(a.T)#和print(b)结果一致

    #使用numpy中transpose():
    c=np.transpose(a)
    print(c,c.shape)

    #多维数组进行转置：
        a=a.reshape(2,3,4)
        print(a,a.shape)
        b=np.transpose(a)
        print(b.shape)#     结果为4,3,2  默认的将i和k进行交换

        c=np.transpose(a,(1,2,0))
        print(c.shape)#     结果为3,4,2  三维数组的维度依次为 0 1 2，上边的方法是进行指定维度的转置

#算数函数

a=np.arange(9).reshape(3,3)
b=np.array([10,10,10])
print('加法',np.add(a,b))
print('减法',np.subtract(b,a))

#out参数的使用
y=np.empty((3,3))
np.multiply(a,10,out=y)
print(y)


#三角函数：
a=np.array([0,30,60,90])
print(np.sin(a))

a=np.arry([1.0,4.55,1.23,0.567,25.532])
print('四舍五入：',np.around(a))
print('向上取整：',np.ceil(a))
print('向下取整：',np.floor(a))


#统计函数：
    #聚合函数：#搜索numpy的聚合函数都有哪些

        #power函数的使用：
        numpy.power()#函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂
        a=np.arange(1,13).reshape(3,4)
        print('原数组',a)
        print('power:',np.power(a,2))

        #power中out的使用
        x=np.arange(5)
        y=np.zeros(10)
        np.power[2,x,out=y[:5]]#    2的x次方 依次存入y的0-4位置   存放时要指定位置,制定的数量要与x内元素的数目相同

        #median()：   中位数
        #一维数组的中位数：
        a=np.array([4,3,2,5,2,1])
        #对数组排序[1,2,2,3,4,5] 数组中元素个数为偶数 中位数指：中间两个数的平均值
        print(np.median(a))

        a=np.array([4,3,2,5,2])
        #排序 数组中元素个数为奇数  中位数指中间的值

        #二维数组   要通过axis指定轴
        a=np.arange(1,13).reshape(3,4)
        print(a)
        print('垂直方向',np.median(a,axis=0))
        print('水平方向',np.median(a,axis=1))

        #mean   求平均值
        #一维数组：
        a=np.array([4,3,2,5,2])
        print(np.mean(a))
        #二维数组   axis指定轴求平均：
        a=np.arange(1,13).reshape(3,4)
        print(a)
        print('不指定axis:'np.mean(a))#结果为所有值加起来的平均值
        print('垂直方向',np.mean(a,axis=0))
        print('水平方向',np.mean(a,axis=1))

        #sum()  max()   min()   argmax()  argmin()
        a=np.array([4,3,2,5,2])
        print('max:',np.max(a))
        print('min:',np.min(a))
        print('sum:',np.sum(a))
        print('argmax(最大值的下标):',argmax(a))
        print('argmin:',argmin(a))