NumPy2: 数组的基本操作

素颜马尾好姑娘i 2022-05-16 08:37 204阅读 0赞

# 1.一维数组的索引和切片 #

from numpy import *
    a=arange(9)
    print(a)
    #数组切片，类似于序列操作
    print(a[3:7])
    print(a[:7:2])
    print(a[::-1]) #逆序

# 2.多维数组的索引和切片 #

from numpy import *
    #改变数组维度
    b = arange(24).reshape(2,3,4)
    print(b)
    #访问单个数组元素
    print(b[1,1,1])
    #第一维度所有的[1,1]位置的元素
    print(b[:,1,1])
    #第一维度所有元素
    print(b[0])
    print(b[0,:,:])  #等价于b[0]
    print(b[0,...]) #等价于b[0],多个":"可以用"..."代替
    #可以在数组任意维度中,做一维数组支持的切片
    #把三维数组看作多个楼层，多个行，多个列的房间号分布
    print(b[0,1,::2]) #第0层，第1行，列每隔2选一个
    print(b[...,2])   #所有楼层，所有行，第2列的房间号
    print(b[0,:,-1])   #第一层，最后一列所有房间
    print(b[0,::-1,-1])   #第一层，最后一列所有房间反向选取
    #如果多维数组中执行翻转一维数组的命令，将在第一维度上翻转所有元素
    print(b[::-1])

# 3.改变多维数组的维度 #

from numpy import *
    def print_line():
        print("==="*20)
    #1.reshape函数，变为多维
    b=arange(24).reshape(4,6)
    print(b)
    print_line()
    #2.ravel展平数组,返回一个视图
    print(b.ravel())
    print(b)
    print_line()
    #3.flatten
    #功能同ravel，不过会实际分配内存来保存结果，ravel只是展开一个视图
    c=b.flatten()
    print(c)
    print(b)
    print_line()
    #4.用元组设置维度,同reshape()，直接改变数组
    b.shape=(3,8)
    print(b)
    print_line()
    #5.transpose在线性代数中常用的转置矩阵
    d=b.transpose()
    print(d)
    #5.resize:和reshape功能一样，但是resize直接改变数组本身
    b.resize((2,12))
    print(b)

# `4.数组的组合` #

import numpy as np
    from numpy import *
    def print_line():
        print("==="*20)
    a = arange(9).reshape(3,3)
    b=2*a
    print(a)
    print(b)
    print_line()
    #1.水平组合
    print(hstack((a,b)))
    print(concatenate((a,b),axis=1))
    print_line()
    #2.垂直组合
    print(vstack((a,b)))
    print(concatenate((a,b),axis=0))
    print_line()
    #3.深度组合：沿“深度”进行叠加
    print(dstack((a,b)))
    #4.列组合：
    #对于一维数组，按列方向进行组合
    oned=arange(2)
    twice_ond=oned*2
    print(column_stack((oned,twice_ond)))
    #[[0 0]
     #[1 2]]
     #对于多维数组，功能同hstack()
    #5.行组合
    #对于一维数组，按行方向进行组合
    print(row_stack((oned,twice_ond)))
    #[[0 1]
    #[0 2]]
    #对于多维数组，功能同vstack()

# 5.数组的分割 #

import numpy as np
    from numpy import *
    def print_line():
        print("==="*20)
    a = arange(9).reshape(3,3)
    print(a)
    #1.水平分割
    b=hsplit(a,3)
    for item in b:
        print(item)
    print_line()
    c=split(a,3,axis=1)
    print(type(c))
    for item in c:
        print(item)
    print_line()
    #2.垂直分割
    b=vsplit(a,3)
    for item in b:
        print(item)
    c=split(a,3,axis=0)
    for item in c:
        print(item)
    print_line()
    #3.深度分割
    #按深度方向，切蛋糕,切完之后维度是(3,3,1)
    c=arange(27).reshape(3,3,3)
    print(c)
    d=dsplit(c,3)
    print(type(d))
    for item in d:
        print(item.shape)

### `6.数组的属性` ###

`除了shape和dtype属性之外，ndarray对象还有很多其他属性；`

\#1.ndim数组维度\#

2.size：数组元素总数

\#3.itemsize:数组中单个元素所占内存字节数  
\#4.nbytes:size\*itemsize 整个数组所占存储空间

\#5.T 等效于transpose  
\#对于一维数组,.T就是其本身  
a=arange(6)  
print(a.T)

\#6.复数  
\#7.flat:迭代器  
\#是唯一获得flatiter对象的方式，可以像遍历一维数组一样去遍历多维数组

import numpy as np
    from numpy import *
    b=arange(24).reshape(2,12)
    #1.ndim数组维度
    print(b.ndim)
    #2.size：数组元素总数
    print(b.size)
    #3.itemsize:数组中单个元素所占内存字节数
    print(b.itemsize)
    #4.nbytes:size*itemsize
    #整个数组所占存储空间
    print(b.nbytes)
    #5.T 等效于transpose
    b.resize(6,4)
    print(b)
    print(b.T)
    #对于一维数组,.T就是其本身
    a=arange(6)
    print(a.T)
    #6.复数
    c=array([1.j+1,2.j+3])
    print(c)
    print(c.real)
    print(c.imag)
    print(c.dtype)
    #7.flat:迭代器
    #是唯一获得flatiter对象的方式，可以像遍历一维数组一样去遍历多维数组
    b=arange(4).reshape(2,2)
    print(b)
    f = b.flat
    for item in f:
        print(item)
    #可以用flatiter直接获取一个数组元素
    print(b.flat[2])
    print("*"*20)
    #可以获取多个元素
    print(b.flat[[1,3]])
    #flat属性可以被赋值,对flat属性赋值将导致整个数组元素都被覆盖
    b.flat=8
    print(b)
    #对指定flat赋值，改变相对应元素
    b.flat[[1,2]]=2
    print(b)

7.数组的转换

`数组转换成python列表`

import numpy as np
    from numpy import *
    b=array([1.+1.j,3.+3.j])
    print(b)
    #[1.+1.j 3.+3.j]
    #tolist:将Numpy数组转换成Python列表
    print(b.tolist())
    #[(1+1j), (3+3j)]
    print("*"*88)
    #astype:转换数组时指定数据类型
    print(b.astype(int))  #丢掉虚数部分
    print(b.astype('complex'))  #可以字符串做参数