首页 > > 网络编程 > 其它 >

numpy学习笔记 - numpy数组的常见用法

2018-08-26 17:32:59来源：博客园阅读 ()

# -*- coding: utf-8 -*-

"""

主要记录代码，相关说明采用注释形势，供日常总结、查阅使用，不定时更新。

Created on Mon Aug 20 23:37:26 2018

@author: Dev

"""

import numpy as np

from datetime import datetime

import random

对a,b两个列表的相同位的元素进行运算求和：

# 纯Python
def pythonSum(n):
    # 对列表循环计算
    a = [x for x in range(n)]
    b = [x for x in range(n)]
    c = []
    for i in range(len(a)):
        a[i] = i ** 2
        b[i] = i ** 3
        c.append(a[i] +b[i])
    return c

# numpy
def numpySum(n):
    # 直接对数组操作
    a = np.arange(n) ** 2
    b = np.arange(n) ** 3
    c = a + b
    return c

# 效率比较
size = 1000
# pythonSum()
start = datetime.now()  # 起始时间
c = pythonSum(size)
delta = datetime.now() - start  # pythonSum()的运行时间
print("The last two elements: ", c[-2:])    # 打印最后两个元素，确认准确性
print("PythonSum elapsed time in microseconds: ", delta.microseconds)   # 以微秒为单位显示运行时间

# pythonSum结果

The last two elements: [995007996, 998001000]
PythonSum elapsed time in microseconds: 999

# numpySum()
start = datetime.now()
c = numpySum(size)
delta = datetime.now() - start
print("The last two elements: ", c[-2:])
print("NumpySum elapsed time in microseconds: ", delta.microseconds)

# numpySum结果

The last two elements: [995007996 998001000]
NumpySum elapsed time in microseconds: 0

可以看出使用numpy数组的速度超快~

numpy数组

a = np.arange(5)

print(a.dtype)

多维数组

m = np.array([np.arange(2), np.arange(2)]) # 创建一个二维数组

print(m)

# 创建元素为0的数组

zeros = np.zeros(10)

zeros_2 = np.zeros((3, 6)) # 元素为0的3*6数组

# 创建元素随机(empty)的数组

empty = np.empty((2, 3, 2))

# 访问数组元素

a = np.array(([1, 2], [3, 4]))

print(a[0, 0])

print(a[0, 1])

print(a[1, 0])

print(a[1, 1])

数组元素的数据类型

print(np.float64(42)) # float浮点型

print(np.float(True))

print(np.float(False))

print(np.int8(42.0)) # int整型

print(np.bool(42)) # Boolean布尔型

print(np.bool(0))

print(np.bool(42.0))

# 创建数组时定义元素的数据类型

print(np.arange(7, dtype=np.uint16))

print(np.arange(9, dtype=np.float64))

数据类型转换

# 类型转换时出现的TypeError异常

try:

print(np.int(42.0 + 1.j))

except TypeError:

print("TypeError: can't convert complex to int!")

arr = np.array([1, 2, 3, 4, 5])

print(arr.dtype) # 元素类型

float_arr = arr.astype(np.float64)

print(float_arr.dtype)

arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])

print(arr.dtype)

int_arr = arr.astype(np.int32) # 将float64类型转换为int32类型

# 将字符串数组转换为字符型

numeric_string = np.array(['1.25', '-9.6', '42'], dtype=np.string_)

print(numeric_string.astype(float)) # 再转换为float类型

字符编码

print(np.arange(7, dtype='f')) # float32

print(np.arange(7, dtype='d')) # float64

print(np.arange(7, dtype='D')) # complex128

print(np.dtype(float))

print(np.dtype('f'))

print(np.dtype('d'))

print(np.dtype('F'))

print(np.dtype('D'))

print(np.dtype('f8'))

print(np.dtype('float64'))

# dtype类的属性

t = np.dtype('float64')

print(t.char) # 字符编码

print(t.type) # t的类型

print(t.str)

自定义数据类型

# [(字段1, 类型, 长度), (字段2, 类型, 长度), ...]

t = np.dtype([('name', np.str_, 40), ('numitems', np.int32), ('price', np.float32)])

print(t)

print(t.name)

itemz = np.array([('Meaning of life DVD', 42, 100), ('Butter', 13, 2.72)]) # 按照格式生成数组

数组与标量的计算

arr = np.array([[1, 2, 3], [4, 5, 6]])

print(arr * arr) # 对应位的元素相乘

print(arr - arr) # 对应位的元素相减

print(1 / arr) # 取倒数

print((arr ** 2) ** 0.5) # 平方后开根号

一维数组的索引与切片(与列表切片用法相似)

a = np.arange(9)

print(a[3: 7])

print(a[:7:2]) # 从0到6，步长为2

s = slice(3, 7, 2) # 先设定切片位置及步长，再调用

print(a[s])

print(a[::-1]) # 倒序排列1

s = slice(None, None, -1) # 倒序排列2

print(a[s])

多维数组的切片与索引

b = np.arange(24).reshape(2, 3, 4)

print(b.shape) # 数组b的维数

# 使用索引与切片选取指定元素

print(b[0,0,0])

print(b[:,0,0])

print(b[0]) # 第一维的所有元素

print(b[0, :, :]) # 第一维的所有元素

print(b[0, ...]) # 第一维的所有元素

print(b[0,1]) # 第一维第二行

print(b[0,1,::2]) # 以2为步长

print(b[...,1]) # 两个维的第一列

print(b[:,1]) # 两个维的第一行

print(b[0,:,1]) # 第一维第一列

print(b[0,:,-1]) # 第一维最后一列

print(b[0,::-1, -1]) # 第一维最后一列的倒序排列

print(b[0,::2,-1]) # 第一维的第0行和第2行的最后一个元素

print(b[::-1]) # 两个维倒序

s = slice(None, None, -1) # 所有元素倒序排列

print(b[(s, s, s)])

布尔型索引（mask）

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])

random.seed(200) # 设置随机种子

data = np.random.random((7, 4))

print(names == 'Bob') # 生成布尔型mask

print(data[names == 'Bob']) # 根据mask的值匹配data数组中的元素

print(data[names == 'Bob', 2:]) # 匹配值从第三列到最后一列的元素

print(data[names == 'Bob', 3]) # 匹配值第四列的元素

names != 'Bob'

data[~(names == 'Bob')]

mask = (names == 'Bob') | (names == 'will') # 或运算符

data[mask]

data[data < 0] = 0

data[names != 'Joe'] = 7

花式索引（索引乱序）

arr = np.empty((8, 4))

for i in range(8):

arr[i] = i

arr[[4, 3, 0, 6]] # 根据索引的顺序取值

arr[[-3, -5, -7]]

arr = np.arange(32).reshape((8, 4))

arr[[1, 5, 7, 2], [0, 3, 1, 2]]

arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]

arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]

数组转置

arr = np.arange(15).reshape((3, 5))

arr.reshape((5,3))

print(arr.T)

改变数据维度

b = np.arange(24).reshape((2, 3, 4))

print(b)

print(b.ravel()) # 将多维数组将为一维

print(b.flatten())

b.shape = (6, 4)

print(b)

print(b.transpose())

b.resize((2, 12))

print(b)

注： flatten()与ravel()的区别

# 当修改ravel()返回的值时，会影响原数组；而flatten则不会

arr_a = np.arange(4).reshape(2, 2)

arr_a.ravel()[-1] = 5

print(arr_a) # arr_a的最后一个元素已被修改

arr_a.flatten()[0] = 10

print(arr_a) # 不会影响原数组的第一个元素

组合数组

a = np.arange(9).reshape(3, 3)

print(a)

b = 2 * a

print(b)

# 水平组合

print(np.hstack((a, b)))

print(np.concatenate((a, b), axis=1))

# 竖直组合

print(np.vstack((a, b)))

print(np.concatenate((a, b), axis=0))

# 深度组合deep

print(np.dstack((a, b)))

# column_stack & row_stack(与hstack & vstack效果类似)

oned = np.arange(2)

print(oned)

twice_oned = 2 * oned

print(twice_oned)

print(np.column_stack((oned, twice_oned)))

print(np.column_stack((a, b)) == np.hstack((a, b)))

print(np.row_stack((oned, twice_oned)))

print(np.row_stack((a, b)))

print(np.row_stack((a, b)) == np.vstack((a, b)))

数组的分割

a = np.arange(9).reshape(3, 3)

print(a)

# 从水平方向分成三列（跨列）

print(np.hsplit(a, 3))

print(np.split(a, 3, axis=1))

# 从竖直方向分成三行（跨行）

print(np.vsplit(a, 3))

print(np.split(a, 3, axis=0))

# 深度分割

c = np.arange(27).reshape(3, 3, 3)

print(c)

print(np.dsplit(c, 3))

数组的属性

b = np.arange(24).reshape(2, 12)

b.ndim # 维度

b.size # 元素个数

b.itemsize # 单个元素的大小

b.nbytes # 整个数组的大小（itemsize * size）

# 复数

b = np.array([1.+1.j, 3.+2.j])

b.real # 实部

b.imag # 虚部

数组的转换

b = np.arange(4).reshape(2, 2)

b.flat # 将数组转换为一维数组

for i in range(len(b.flat)): # 循环访问数组元素

print(b.flat[i])

b = np.array([1.+1.j, 3.+2.j])

print(b)

print(b.tolist()) # 转换为list

print(b.tostring()) # 转换为字符

# 使用np.fromstring将字符串转换为指定格式

print(np.fromstring(b'\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x00@', dtype=complex))

a_t = np.fromstring('20:42:53', sep=':', dtype=int)

print(a_t)

print(a_t.dtype)

# 复数转换为整型时会舍弃虚部

print(b.astype(int))

print(b.astype('complex'))

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有