Numpy 如何操作数组

# --*--coding:utf-8--*--
from numpy import *
"""
复数数组
"""
a = array([1 + 1j, 2, 3, 4])
# 数组类型
print('type:', a.dtype)
# 实部
print(a.real)
# 虚部
print(a.imag)
# 复共轭
print(a.conj())

"""
指定数组类型
"""
a = array([1, 2, 4, 9, 10], dtype=float32)
print(a)

a = array([0, 1.8, 3.3, 4.1], dtype=uint8)
print(a)

"""
类型转换
"""
a = array([1.5, -3, -3.3],
         dtype=float32)
b = asarray(a, dtype=float64)
print('asarray类型转换：', b)

c = a.astype(uint8)
print('astype类型转换：', c)

a = array((1,2,3,4), dtype=int32)
d = a.view(uint8)
print('view类型转换：', d)

# --*--coding:utf-8--*--
from numpy import *
from numpy.random import rand
"""
求和
"""
a = array([[1,2,3], [4,5,6]])
# 所有元素和
print('all:', sum(a))
# 指定求和维度
print('维度和：', sum(a, axis=0))
print('维度和：', sum(a, axis=-1))

"""
求积
"""
# 所有元素积
print('all:', prod(a))
# 指定求积维度
print('维度积：', prod(a, axis=0))
print('维度积：', prod(a, axis=1))

"""
最大最小值
"""
a = rand(3, 4)
print(a)
# 全局最小
print('all:', a.min())
# 某个轴最小
print('axis:', a.min(axis=1))
# 全局最大
print('all:', a.max())
# 某个轴最大
print('axis:', a.max(axis=-1))

# 最大最小值的位置
print('max in: ', a.argmax())
print('min in ', a.argmin())

"""
均值
"""
a = array([[1,2,3],[4,5,6]])
print('avg:', a.mean())
print('avg: ', average(a, axis=0))

"""
标准差
"""
# 标准差
print('std: ', a.std(axis=1))
# 方差
print(a.var(axis=1))
print(var(a, axis=-1))
print(std(a, axis=-1))

# clip方法,将数值限制在某个范围
print(a)
# 小于2的变成2，大于4的变成4
print(a.clip(2, 4))

# ptp方法，计算最大值和最小值之差
print(a.ptp(axis=1))
print(a.ptp())

# round方法
a = array([1.35, 2.5, 1.5])
print(a.round())
# 近似到一位小数
print(a.round(decimals=1))

# --*-- coding:utf-8 --*--
from numpy import *
"""
数组排序
"""

# sort函数
names = array(['Bob', 'Sue', 'Jan', 'Ad'])
print('names sort:', sort(names))
weights = array([20, 93, 53, 62])
print('weights sort:', sort(weights))

# argsort函数
ordered_indices = argsort(weights)
print(ordered_indices)
print(weights[ordered_indices])

"""
二维数组排序
"""
a = array([
        [.2, .1, .5],
        [.4, .8, .3],
        [.9, .6, .7]
    ])
print('all: \n', sort(a))
print('axis: \n', sort(a, axis=0))

"""
searchsorted函数，接受两个参数，第一个必须是已排序的数组
"""
sorted_array = linspace(0, 1, 5)
values = array([.1, .8, .3, .31, .9, .45])
print('searcgsorted: ', searchsorted(sorted_array, values))

"""
数组形状
"""
# --*-- coding:utf-8 --*--
from numpy import *
# 修改数组形状
a = arange(6)
print('origin: \n', a)
a.shape = 2, 3
print('after modified: \n', a)
print('after reshape: \n', a.reshape(3, 2))

# 使用newaxis增加数组维数
a = arange(3)
print('shape:', shape(a))
y = a[newaxis, :]
print(shape(y))
print(y)
y = a[newaxis, newaxis, :]
print(shape(y))
print(y)

# squeeze方法去除多余的轴
a = arange(6)
a.shape = (2, 1, 3)
b = a.squeeze()
print('shape of b:', b.shape)

# 数组转置
"""
PS:
    1、对于复述数组，转置不返回复共轭，只是单纯交换轴的位置
    2、转置可以作用于多维数组
"""
print(a)
print('transpose: \n', a.transpose())

print(a.T)

# 数组连接
x = array([
        [0,1,2],
        [10,11,12]
    ])
y = array([
        [50,51,52],
        [60,61,62]
    ])

z = concatenate((x, y))
print(z)

# Flatten数组，将多维数组转化为1维数组,返回数组的复制，不改变原数组的值
a = array([[0,1],
           [2,3]])
b = a.flatten()
print(b)

# flat属性，相当于返回所有元组组成的一个迭代器
print(a.flat)

# reval方法,将多位数组转化为1维数组
b = a.ravel()
print(b)

# atleast_xd函数，保证数组至少有x维
x = 1
print('1d:',atleast_1d())

a = array([1,2,3])
b = atleast_2d(a)
print('2d:', b)

c = atleast_3d(b)
print('3d: ', c)

# --*--coding:utf-8--*--
import numpy as np
"""
对角线
"""
a = np.array([11,22,33,44,55,66,77,88,99])
a.shape = 3, 3
print(a)

# 对角线元素
print('all :\n', a.diagonal())

# 对角线元素偏移，正数代表右移，负数代表左移
print('左移：\n', a.diagonal(offset=-1))
print('右移：\n', a.diagonal(offset=1))

# 更新对角线的值
i = [0, 1, 2]
a[i, i] = 20
print('update: \n', a)

# 修改次对角线的值
i = np.array([0, 1])
a[i, i+1] = 21
print('修改次对角线：\n', a)

# --*--coding:utf-8--*--
import numpy as np
"""
数组与字符串的转换
"""
# tostring方法
a = np.array([[1, 2], [3, 4]], dtype = np.uint8)
print('a: ', a.tostring())
# 按照列读取数据
print('a Fortran:', a.tostring(order='F'))

# fromstring函数，从字符串中独处数据，但要指定类型
s = a.tostring()
a = np.fromstring(s, dtype=np.uint8)
a.shape = 2, 2
print(a)

# --*--coding:utf-8--*--
import numpy as np
"""
生成数组的函数
"""
# arange(start, stop=None, step=1, dtype=None)，类似range函数，返回数组
# 允许非整数值输入，产生一个菲整形的数组
a = np.arange(5)
print(a)

# linspace(start, stop, N)，产生N个等距分布与【】
print(np.linspace(0, 10, 5))

# logspace(start, stop, N),产生N个对数等距分布的数组，默认以10为底
print(np.logspace(0, 8, 5))

# meshgrid，二维平面中生成一个网格
x_lable = np.linspace(-1, 1, 5)
y_lable = np.linspace(-1, 1, 5)
x, y = np.meshgrid(x_lable, y_lable)
print(x, y, end='\n')

# 1、ogrid(start:end:step)：meshgrid(indexing='ij', sparse=True)，生成列矩阵
# 2、mgrid(start:end:step): meshgrid(indexing='ij', sparse=False)，生成行矩阵
x, y = np.ogrid[-10:10:5, 10:30:5]
print('{} \n {}'.format(x, y))

# r_:产生行向量
# c_:产生列向量

print(np.r_[1:10:2])
print(np.c_[1:10:2])

# ones(shape, dtype)，定制一个全1的数组，数组类型可指定
# zeros(shape, dtype),定制一个全0的数组，数组类型可指定
# empty(shape, dtype, order)，产生一个指定大小的数组(指向的内存未初始化，故值随机)
print('全1:\n', ones([3, 5], dtype = np.float32))
print('全0:\n', zeros([3, 5], dtype = np.float32))
print(np.empty(5))

# empty_like(array)、ones_like(array)、zeros_like(array),产生一个与a大小一样，类型一样的对应数组
a = np.arange(0, 10, 2)
print(a)
print('empty like:\n', np.empty_like(a))
print('zeros like:\n', np.zeros_like(a))
print('ones like:\n', np.ones_like(a))

# identity(n, dtype)，产生一个n*n的单位矩阵
print('identity: \n', np.identity(5))