Python-numpy

1.numpy入门

numpy介绍（终极目的：读取文件数字数据进行处理，文字处理用pandas

 

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

 

NumPy Ndarray 对象:NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。 ndarray 对象是用于存放同类型元素的多维数组。 ndarray 中的每个元素在内存中都有相同存储大小的区域。

 

ndarray 内部由以下内容组成：一个指向数据（内存或内存映射文件中的一块数据）的指针。 数据类型或 dtype，描述在数组中的固定大小值的格子。 一个表示数组形状（shape）的元组，表示各维度大小的元组。 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

 

ndarray 的内部结构:

 

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

名称:　　　描述:

object 　　数组或嵌套的数列

dtype 　　 数组元素的数据类型，可选

copy 　　  对象是否需要复制，可选

order 　　 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）

subok 　　默认返回一个与基类类型一致的数组 ndmin 指定生成数组的最小维度

 

实例:

import numpy as np a = np.array([1,2,3]) print (a) --> [1 2 3]

# 多于一个维度

import numpy as np a = np.array([[1, 2], [3, 4]]) print (a) -->[[1 2] [3 4]]

# 最小维度

import numpy as np a = np.array([1, 2, 3, 4, 5], ndmin = 2) print (a) --> [[1 2 3 4 5]]

#复数矩阵# dtype 参数

import numpy as np a = np.array([1, 2, 3], dtype = complex) print (a)--> [1.+0.j 2.+0.j 3.+0.j]

 

2.numpy数据类型

名称 　　描述

bool_　　 布尔型数据类型（True 或者 False）

int_ 　　默认的整数类型（类似于 C 语言中的 long，int32 或 int64）

intc 　　与 C 的 int 类型一样，一般是 int32 或 int 64

intp　　 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）

int8 　　字节（-128 to 127） int16 整数（-32768 to 32767） int32 整数（-2147483648 to 2147483647）

int64　　 整数（-9223372036854775808 to 9223372036854775807）

uint8 　　无符号整数（0 to 255）

uint16 　　无符号整数（0 to 65535）

uint32 　　无符号整数（0 to 4294967295）

uint64 　　无符号整数（0 to 18446744073709551615）

float_ float64 　　类型的简写 float16 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位

float32 　　单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位

float64 　　双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位

complex_ complex128 　　类型的简写，即 128 位复数

complex64 　　复数，表示双 32 位浮点数（实数部分和虚数部分）

complex128 　　复数，表示双 64 位浮点数（实数部分和虚数部分）

 

实例 1

import numpy as np # 使用标量类型 dt = np.dtype(np.int32) print(dt)

实例 2

import numpy as np # int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替 dt = np.dtype('i4') print(dt)

实例 3

import numpy as np # 字节顺序标注 dt = np.dtype('<i4') print(dt)

实例 4

# 首先创建结构化数据类型

import numpy as np dt = np.dtype([('age',np.int8)]) print(dt)

实例 5

# 将数据类型应用于 ndarray 对象

import numpy as np dt = np.dtype([('age',np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print(a)

实例 6

# 类型字段名可以用于存取实际的 age 列

import numpy as np dt = np.dtype([('age',np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print(a['age'])

实例 7

import numpy as np student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) print(student)

实例 8

import numpy as np student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student) print(a)

 

3.创建数组

1.特殊方式创建数组

numpy.emptynumpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

(numpy.empty(shape, dtype = float, order = 'C') 参数说明： 参数 描述 shape 数组形状 dtype 数据类型，可选 order 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。)

 

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

(numpy.zeros(shape, dtype = float, order = 'C') 参数说明： 参数 描述 shape 数组形状 dtype 数据类型，可选 order 'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组)

numpy.ones创建指定形状的数组，数组元素以 1 来填充：numpy.ones(shape, dtype = None, order = 'C')

实例

import numpy as np

# 默认为浮点数

x = np.zeros(5) print(x)

# 设置类型为整数

y = np.zeros((5,), dtype = np.int) print(y)

# 自定义类型

z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')]) print(z)

 

 

2.从已有数据创建数组

numpy.asarray

numpy.asarray(a, dtype = None, order = None)

参数 　　描述

a　　　  任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组

dtype　  数据类型，可选

order     可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

 

将列表转换为 ndarray:

实例

import numpy as np x = [1,2,3] a = np.asarray(x) print (a)

 

将元组转换为 ndarray:

实例

import numpy as np x = (1,2,3) a = np.asarray(x) print (a)

 

将元组列表转换为 ndarray:

实例

import numpy as np x = [(1,2,3),(4,5)] a = np.asarray(x) print (a)

 

设置了 dtype 参数：

实例

import numpy as np x = [1,2,3] a = np.asarray(x, dtype = float) print (a)

 

 

3.从数组范围创建数组

numpy.arange(start, stop, step, dtype)

参数 　　描述

start　　 起始值，默认为0

stop 　　终止值（不包含）

step 　　步长，默认为1

dtype 　 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

 

生成 0 到 5 的数组:

实例 

import numpy as np x = np.arange(5) print (x)

 

设置了起始值、终止值及步长：

实例

import numpy as np x = np.arange(10,20,2) print (x)

 

numpy.linspacenumpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数 　　描述

start 　　序列的起始值

stop 　　序列的终止值，如果endpoint为true，该值包含于数列中

num 　　要生成的等步长的样本数量，默认为50

endpoint 　　该值为 true 时，数列中包含stop值，反之不包含，默认是True。

retstep 　　如果为 True 时，生成的数组中会显示间距，反之不显示。

dtype 　　ndarray 的数据类型

 

 

numpy.logspace 函数用于创建一个于等比数列。

格式如下： np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

参数 　　描述

start 　　序列的起始值为：base ** start

stop　　 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中

num 　　要生成的等步长的样本数量，默认为50

endpoint 　　该值为 true 时，数列中中包含stop值，反之不包含，默认是True。

base 　　对数 log 的底数。

dtype　　 ndarray 的数据类型

 

4.数组操作

1.切片与索引

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。 ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

实例

import numpy as np a = np.arange(10) s = slice(2,7,2)

# 从索引 2 开始到索引 7 停止，间隔为2

print (a[s])

以上实例中，我们首先通过 arange() 函数创建 ndarray 对象。 然后，分别设置起始，终止和步长的参数为 2，7 和 2。

 

我们也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作：

实例

import numpy as np a = np.arange(10) b = a[2:7:2]

# 从索引 2 开始到索引 7 停止，间隔为 2

print(b)

冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。

 

多维数组同样适用上述索引提取方法：

实例

import numpy as np a = np.array([[1,2,3],[3,4,5],[4,5,6]]) print(a)

# 从某个索引处开始切割

print('从数组索引 a[1:] 处开始切割')

print(a[1:])

 

切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。

实例

import numpy as np a = np.array([[1,2,3],[3,4,5],[4,5,6]])

print (a[...,1])# 第2列元素

print (a[1,...])# 第2行元素

print (a[...,1:])# 第2列及剩下的所有元素

 

 

2.数组广播

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。 如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

实例 import numpy as np a = np.array([1,2,3,4]) b = np.array([10,20,30,40]) c = a * b print (c)

实例 import numpy as np a = np.array([[ 0, 0, 0], [10,10,10], [20,20,20], [30,30,30]]) b = np.array([1,2,3]) print(a + b)

实例 import numpy as np a = np.array([[ 0, 0, 0], [10,10,10], [20,20,20], [30,30,30]]) b = np.array([1,2,3]) bb = np.tile(b, (4, 1)) # 重复 b 的各个维度 print(a + bb)

 

 

 

3.数组迭代

NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。 迭代器最基本的任务的可以完成对数组元素的访问。 接下来我们使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代。

实例

import numpy as np

a = np.arange(6).reshape(2,3)

print ('原始数组是：')

print (a)

print ('\n')

print ('迭代输出元素：')

for x in np.nditer(a):

　　print (x, end=", " )

print ('\n')

 

4.数组操作

修改数组形状

numpy.reshapenumpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下：

numpy.reshape(arr, newshape, order='C') arr：要修改形状的数组 newshape：整数或者整数数组，新的形状应当兼容原有形状 order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。

 

 

翻转数组

numpy.ndarray.flatnumpy.ndarray.flat 是一个数组元素迭代器，实例如下:

import numpy as np a = np.arange(9).reshape(3,3) print ('原始数组：') for row in a: print (row)#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：print ('迭代后的数组：')for element in a.flat: print (element)

 

numpy.ndarray.flattennumpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：

ndarray.flatten(order='C') 参数说明： order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

 

numpy.ravelnumpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。该函数接收两个参数：

numpy.ravel(a, order='C') 参数说明： order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

 

numpy.transposenumpy.transpose 函数用于对换数组的维度，格式如下：numpy.transpose(arr, axes)

参数说明: arr：要操作的数组 axes：整数列表，对应维度，通常所有维度都会对换。 import numpy as np a = np.arange(12).reshape(3,4) print ('原数组：') print (a ) print ('\n') print ('对换数组：') print (np.transpose(a))

 

numpy.swapaxesnumpy.swapaxes 函数用于交换数组的两个轴，格式如下：

numpy.swapaxes(arr, axis1, axis2) arr：输入的数组 axis1：对应第一个轴的整数 axis2：对应第二个轴的整数

 

修改数组维度

维度 　　　　　　　 描述

broadcast  　　　　 产生模仿广播的对象

broadcast_to  　　  将数组广播到新形状

expand_dims　　    扩展数组的形状

squeeze 　　　　　 从数组的形状中删除一维条目

 

numpy.broadcastnumpy.broadcast 用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。该函数使用两个数组作为输入参数，如下实例：

import numpy as np x = np.array([[1], [2], [3]]) y = np.array([4, 5, 6]) # 对 y 广播 x b = np.broadcast(x,y) # 它拥有 iterator 属性，基于自身组件的迭代器元组 print ('对 y 广播 x：') r,c = b.iters # Python3.x 为 next(context) ，Python2.x 为 context.next() print (next(r), next(c)) print (next(r), next(c)) print ('\n') # shape 属性返回广播对象的形状 print ('广播对象的形状：') print (b.shape) print ('\n') # 手动使用 broadcast 将 x 与 y 相加 b = np.broadcast(x,y) c = np.empty(b.shape)

 

numpy.broadcast_tonumpy.broadcast_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError。numpy.broadcast_to(array, shape, subok)

import numpy as np a = np.arange(4).reshape(1,4) print ('原数组：') print (a) print ('\n') print ('调用 broadcast_to 函数之后：') print (np.broadcast_to(a,(4,4)))

 

numpy.expand_dimsnumpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状，函数格式如下: numpy.expand_dims(arr, axis)

 

 

连接数组

函数  　　　　　　描述

concatenate 　　连接沿现有轴的数组序列

stack 　　　　沿着新的轴加入一系列数组。

hstack 　　　　水平堆叠序列中的数组（列方向）

vstack 　　　　竖直堆叠序列中的数组（行方向）

 

numpy.concatenatenumpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：numpy.concatenate((a1, a2, ...), axis)

 

numpy.stacknumpy.stack 函数用于沿新轴连接数组序列，格式如下：numpy.stack(arrays, axis)

参数说明： arrays相同形状的数组序列 axis：返回数组中的轴，输入数组沿着它来堆叠

 

numpy.hstacknumpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。

 

numpy.vstacknumpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。

 

 

分割数组

函数 　　　数组及操作

split 　　   将一个数组分割为多个子数组

hsplit 　　 将一个数组水平分割为多个子数组（按列）

vsplit　　  将一个数组垂直分割为多个子数组（按行）

 

numpy.splitnumpy.split 函数沿特定的轴将数组分割为子数组，格式如下：numpy.split(ary, indices_or_sections, axis)

参数说明： ary：被分割的数组 indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭） axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。

 

numpy.hsplitnumpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。

numpy.vsplitnumpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。

 

 

 

数组元素的添加与删除

函数 　　元素及描述

resize 　　返回指定形状的新数组

append　　 将值添加到数组末尾

insert 　　沿指定轴将值插入到指定下标之前

delete 　　删掉某个轴的子数组，并返回删除后的新数组

unique 　　查找数组内的唯一元素

 

 

5.numpy函数

函数  　　描述

add() 　　对两个数组的逐个字符串元素进行连接 multiply() 返回按元素多重连接后的字符串

center() 　　居中字符串

capitalize() 　　将字符串第一个字母转换为大写

title() 　　将字符串的每个单词的第一个字母转换为大写

lower() 　　数组元素转换为小写 upper() 数组元素转换为大写

split() 　　指定分隔符对字符串进行分割，并返回数组列表

splitlines() 　　返回元素中的行列表，以换行符分割

strip()　　 移除元素开头或者结尾处的特定字符

join() 　　通过指定分隔符来连接数组中的元素

replace() 　　使用新字符串替换字符串中的所有子字符串

decode()　　 数组元素依次调用str.decode

encode() 　　数组元素依次调用str.encode

import numpy as np

#numpy.char.add() 函数依次对两个数组的元素进行字符串连接。
print(np.char.add(['hello'], [' word']))

#numpy.char.multiply() 函数执行多重连接。
print(np.char.multiply("abcd ", 3))

#numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。
print(np.char.center('hello', 20, fillchar='*'))

#numpy.char.capitalize() 函数将字符串的第一个字母转换为大写
print(np.char.capitalize('hello'))

#numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower。
#操作数组
print(np.char.lower(['HHH', 'OOO']))
#操作字符串
print(np.char.lower('HELLO'))


#numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。
#分隔符默认为空格
print(np.char.split("i like you"))
# 分隔符为 .
print(np.char.split('www.runoob.com',sep='.'))


# numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。
# 换行符 \n
print(np.char.splitlines('i\nlike runoob?'))


# numpy.char.strip() 函数用于移除开头或结尾处的特定字符。
# 移除字符串头尾的 a 字符
print(np.char.strip('ashok arunooba', 'a'))
# 移除数组元素头尾的 a 字符
print (np.char.strip(['arunooba','admin','java'],'a'))


# umpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串
# 操作字符串
print(np.char.join(":", "runoob"))
# 指定多个分隔符操作数组元素
print(np.char.join([':', '-'], ['runoob', 'google']))

# numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。
print (np.char.replace ('i like runoob', 'oo', 'cc'))

# numpy.char.decode() 函数对编码的元素进行 str.decode() 解码。
a=np.char.encode('runoob','utf-8')
print(a)
print(np.char.decode(a,'utf-8'))