创建相同字符的numpy数组_Numpy入门-数据类型与数组创建

一、常量

1.1 numpy.nan:空值

表示空值，这里两个空值是不相等的

print(np.nan == np.nan)  # False
print(np.nan != np.nan)  # True

函数：numpy.isnan(arg)，这里也使用了numpy.count_nonzero(arg)

经测试：可输入参数为列表与元组，目前来看可能只能输入一个参数

import numpy as np

x = np.array([1, 1, 8, np.nan, 10])
print(x)
# [ 1.  1.  8. nan 10.]

y = np.isnan(x)
print(y)
# [False False False  True False]

z = np.count_nonzero(y)
print(z)  # 1

这里由于教程的误导，找到了另外两个魔法方法的教程：*args和**kwargs

• *args是用来将参数打包成tuple给函数体调用

def function(x, y, *args):
    print(x, y, args)

function(1, 2, 3, 4, 5)
# 1 2 (3,4,5)

• **kwargs是用来将参数打包成dict给函数体调用

def function(**kwargs):
    print(kwargs)

function(a=1, b=2, c=3)
# {'a':1,'b':2,'c':3}

• 这里有一个问题就是三者并存是，必须要满足(arg,*args,**kwargs)的顺序

1.2 numpy.inf:无限大

1.3 numpy.pi:圆周率

1.4 numpy.e:自然对数的底

这三个比较常规

二、数据类型

2.1 数据类型分类

numpy基本数据类型的列举：

2.2 数据类型的创建

在数据类型的创建上，numpy 的数值类型实际上是 dtype 对象的实例。下图为不同字符对应的类型

import numpy as np

a = np.dtype('b1')
print(a.type)  # 
print(a.itemsize)  # 1

a = np.dtype('i1')
print(a.type)  # 
print(a.itemsize)  # 1
a = np.dtype('i2')
print(a.type)  # 
print(a.itemsize)  # 2
a = np.dtype('i4')
print(a.type)  # 
print(a.itemsize)  # 4
a = np.dtype('i8')
print(a.type)  # 
print(a.itemsize)  # 8

a = np.dtype('u1')
print(a.type)  # 
print(a.itemsize)  # 1
a = np.dtype('u2')
print(a.type)  # 
print(a.itemsize)  # 2
a = np.dtype('u4')
print(a.type)  # 
print(a.itemsize)  # 4
a = np.dtype('u8')
print(a.type)  # 
print(a.itemsize)  # 8

a = np.dtype('f2')
print(a.type)  # 
print(a.itemsize)  # 2
a = np.dtype('f4')
print(a.type)  # 
print(a.itemsize)  # 4
a = np.dtype('f8')
print(a.type)  # 
print(a.itemsize)  # 8

a = np.dtype('S')
print(a.type)  # 
print(a.itemsize)  # 0
a = np.dtype('S3')
print(a.type)  # 
print(a.itemsize)  # 3

a = np.dtype('U3')
print(a.type)  # 
print(a.itemsize)  # 12

2.3 数据类型的信息

可以通过numpy.iinfo(numpy.int16)来查看int16的类型信息，其中iinfo的i可以转换为f等，代表浮点数。

import numpy as np

ii16 = np.iinfo(np.int16)
print(ii16.min)  # -32768
print(ii16.max)  # 32767

三、时间日期与时间增量

3.1 datetime64基础

在 numpy 中，我们很方便的将字符串转换成时间日期类型 datetime64（datetime 已被 python 包含的日期时间库所占用）。

datetime64是带单位的日期时间类型，其单位如下：

【例1】在使用字符串创建datetime64类型时，numpy会自己选择对应的单位。（注意字符串之间的连接）

import numpy as np

a = np.datetime64('2020-03-08 20:00:05')
print(a, a.dtype)  # 2020-03-08T20:00:05 datetime64[s]

【例2】在使用字符串创建datetime64时候，可以强制选择使用的单位。

import numpy as np

a = np.datetime64('2020-03', 'D')
print(a, a.dtype)  # 2020-03-01 datetime64[D]

a = np.datetime64('2020-03', 'Y')
print(a, a.dtype)  # 2020 datetime64[Y]

print(np.datetime64('2020-03') == np.datetime64('2020-03-01'))  # True
print(np.datetime64('2020-03') == np.datetime64('2020-03-02'))  #False

【例3】从字符串创建 datetime64 数组时，如果单位不统一，则一律转化成其中最小的单位。

import numpy as np

a = np.array(['2020-03', '2020-03-08', '2020-03-08 20:00'], dtype='datetime64')
print(a, a.dtype)
# ['2020-03-01T00:00' '2020-03-08T00:00' '2020-03-08T20:00'] datetime64[m]

【例4】使用 arange() 创建 datetime64 数组，用于生成日期范围。

import numpy as np

a = np.arange('2020-08-01', '2020-08-10', dtype=np.datetime64)
print(a)
# ['2020-08-01' '2020-08-02' '2020-08-03' '2020-08-04' '2020-08-05'
#  '2020-08-06' '2020-08-07' '2020-08-08' '2020-08-09']
print(a.dtype)  # datetime64[D]

3.2 datetime64 和 timedelta64 运算

【例1】datetime64 和 timedelta64 运算

import numpy as np

b = np.datetime64('2020-03-08') - np.datetime64('202-03-07 08:00')
print(b, b.dtype)  # 956178240 minutes timedelta64[m]

a = np.datetime64('2020-03') + np.timedelta64(20, 'D')
b = np.datetime64('2020-06-15 00:00') + np.timedelta64(12, 'h')
print(a, a.dtype)  # 2020-03-21 datetime64[D]
print(b, b.dtype)  # 2020-06-15T12:00 datetime64[m]

【例2】可以使用timedelta64来进行转换，但（'Y'）和月（'M'）这两个单位无法和其它单位进行运算（一年有几天？一个月有几个小时？这些都是不确定的）。

import numpy as np

a = np.timedelta64(1, 'Y')
b = np.timedelta64(a, 'M')
print(a)  # 1 years
print(b)  # 12 months

【例3】timedelta64 的运算。

import numpy as np

a = np.timedelta64(1, 'Y')
b = np.timedelta64(6, 'M')
c = np.timedelta64(1, 'W')
d = np.timedelta64(1, 'D')
e = np.timedelta64(10, 'D')

print(a)  # 1 years
print(b)  # 6 months
print(a + b)  # 18 months
print(a - b)  # 6 months
print(2 * a)  # 2 years
print(a / b)  # 2.0
print(c / d)  # 7.0
print(c % e)  # 7 days

【例4】numpy.datetime64 与 datetime.datetime 相互转换。

注：astype是numpy中数据类型转换方法，（）中是被转换的类型。

import numpy as np
import datetime

dt = datetime.datetime(year=2020, month=6, day=1, hour=20, minute=5, second=30)
dt64 = np.datetime64(dt, 's')
print(dt64, dt64.dtype)
# 2020-06-01T20:05:30 datetime64[s]

dt2 = dt64.astype(datetime.datetime)
print(dt2, type(dt2))
# 2020-06-01 20:05:30 

3.3 datetime64的应用

【例1】numpy.busday_offset() 工作日功能

numpy.busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)

将指定的偏移量应用于工作日，单位天（'D'）。计算下一个工作日，如果当前日期为非工作日，默认报错。可以指定forward或backward规则来避免报错。（一个是向前取第一个有效的工作日，一个是向后取第一个有效的工作日）。

注：

• 如果为工作日，则返回当天信息。
• offsets是对于偏移天数的设置。
• 这里最重要的是这里的日期一定是两位的，缺少的要用0补全，例如2020-07-09，不能用2020-7-9。

import numpy as np

# 2020-07-10 星期五
a = np.busday_offset('2020-07-10', offsets=1)
print(a)  # 2020-07-13

a = np.busday_offset('2020-07-11', offsets=1)
print(a)
# ValueError: Non-business day date in busday_offset

【例2】numpy.is_busday()返回指定日期是否是工作日。

• 统计一个datatime形式的数组中有几个工作日

这里利用了numpy.arange()；numpy.count_nonzero()。

import numpy as np

# 2020-07-10 星期五
begindates = np.datetime64('2020-07-10')
enddates = np.datetime64('2020-07-20')
a = np.arange(begindates, enddates, dtype='datetime64')
b = np.count_nonzero(np.is_busday(a))
print(a)
# ['2020-07-10' '2020-07-11' '2020-07-12' '2020-07-13' '2020-07-14'
#  '2020-07-15' '2020-07-16' '2020-07-17' '2020-07-18' '2020-07-19']
print(b)  # 6

• 判断某一天所在的周掩码。

注：其中工作日设置为1。

import numpy as np

# 2020-07-10 星期五
a = np.is_busday('2020-07-10', weekmask=[1, 1, 1, 1, 1, 0, 0])
b = np.is_busday('2020-07-10', weekmask=[1, 1, 1, 1, 0, 0, 1])
print(a)  # True
print(b)  # False

【例3】numpy.busday_count()返回两个datetime64之间的工作日数目。

注：这里都需要使用datetime64类型

import numpy as np

# 2020-07-10 星期五
begindates = np.datetime64('2020-07-10')
enddates = np.datetime64('2020-07-20')
a = np.busday_count(begindates, enddates)
b = np.busday_count(enddates, begindates)
print(a)  # 6
print(b)  # -6

四：数组的创建

numpy 提供的最重要的数据结构是 ndaray ，它是 python 的 list 的扩展。

4.1 依据已有数据创建ndarray

【例1】通过 array() 函数创建

注：二维、三维同理

import numpy as np

# 创建一维数组
a = np.array([0, 1, 2, 3, 4])
b = np.array((0, 1, 2, 3, 4))
print(a, type(a))
# [0 1 2 3 4] 
print(b, type(b))
# [0 1 2 3 4] 

【例2】通过 asarray() 函数进行创建

array() 和 asarray() 都可以将结构数据转化为 ndarray，但是 array() 和 asarray() 主要区别就是当数据源是ndarray时，array() 仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 asarray() 不会。

注意：前提是数据源为ndarray。

import numpy as np

x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
y = np.array(x)
z = np.asarray(x)
x[1][2] = 2
print(x,type(x),x.dtype)
# [[1 1 1]
#  [1 1 2]
#  [1 1 1]]  int32

print(y,type(y),y.dtype)
# [[1 1 1]
#  [1 1 1]
#  [1 1 1]]  int32

print(z,type(z),z.dtype)
# [[1 1 1]
#  [1 1 2]
#  [1 1 1]]  int32

【例3】更改为较大的dtype时，其大小必须是array的最后一个axis的总大小（以字节为单位）的除数。

import numpy as np

x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]],dtype=np.int64)
print(x, x.dtype)
# [[1 1 1]
#  [1 1 1]
#  [1 1 1]] int64
x.dtype = np.int32
print(x, x.dtype)
#[[1 0 1 0 1 0]
# [1 0 1 0 1 0]
# [1 0 1 0 1 0]] int32

4.2 依据 ones 和 zeros 填充方式

【例1】零数组的创建

• zero() 函数：返回给定形状和类型的零数组。
• zero_like() 函数：返回与给定数组形状和类型相同的零数组。

import numpy as np

x = np.zeros(5)
print(x)  # [0. 0. 0. 0. 0.]
x = np.zeros([2, 3])
print(x)
# [[0. 0. 0.]
#  [0. 0. 0.]]

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.zeros_like(x)
print(y)
# [[0 0 0]
#  [0 0 0]]

【例2】1数组的创建

与零数组类似，有着相同的结构

• ones() 函数：返回给定形状和类型的1数组。
• ones_like() 函数：返回与给定数组形状和类型相同的1数组。

import numpy as np

x = np.ones(5)
print(x)  # [1. 1. 1. 1. 1.]
x = np.ones([2, 3])
print(x)
# [[1. 1. 1.]
#  [1. 1. 1.]]

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.ones_like(x)
print(y)
# [[1 1 1]
#  [1 1 1]]

【例3】空数组的创建

同上

• empty() 函数：返回一个空数组，数组元素为随机数。
• empty_like() 函数：返回与给定数组具有相同形状和类型的新数组。

import numpy as np

x = np.empty(5)
print(x)
# [1.95821574e-306 1.60219035e-306 1.37961506e-306 
#  9.34609790e-307 1.24610383e-306]

x = np.empty((3, 2))
print(x)
# [[1.60220393e-306 9.34587382e-307]
#  [8.45599367e-307 7.56598449e-307]
#  [1.33509389e-306 3.59412896e-317]]

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.empty_like(x)
print(y)
# [[  7209029   6422625   6619244]
#  [      100 707539280       504]]

【例4】单位数组的创建

单位数组创建依然有着两种方法：

• eye() 函数：返回一个对角线上为1，其它地方为零的单位数组。
• identity() 函数：返回一个方的单位数组。

import numpy as np

x = np.eye(4)
print(x)
# [[1. 0. 0. 0.]
#  [0. 1. 0. 0.]
#  [0. 0. 1. 0.]
#  [0. 0. 0. 1.]]

x = np.eye(2, 3)
print(x)
# [[1. 0. 0.]
#  [0. 1. 0.]]

x = np.identity(4)
print(x)
# [[1. 0. 0. 0.]
#  [0. 1. 0. 0.]
#  [0. 0. 1. 0.]
#  [0. 0. 0. 1.]]

【例5】对角数组的创建

• diag() 函数：提取对角线或构造对角数组。

import numpy as np

x = np.arange(9).reshape((3, 3))
print(x)
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]
print(np.diag(x))  # [0 4 8]
print(np.diag(x, k=1))  # [1 5]
print(np.diag(x, k=-1))  # [3 7]

v = [1, 3, 5, 7]
x = np.diag(v)
print(x)
# [[1 0 0 0]
#  [0 3 0 0]
#  [0 0 5 0]
#  [0 0 0 7]]

【例6】常数数组的创建

常数数组创建有着两种方式：

• full() 函数：返回一个常数数组。
• full_like() 函数：返回与给定数组具有相同形状和类型的常数数组。

import numpy as np

x = np.full((2,), 7)
print(x)
# [7 7]

x = np.full(2, 7)
print(x)
# [7 7]

x = np.full((2, 7), 7)
print(x)
# [[7 7 7 7 7 7 7]
#  [7 7 7 7 7 7 7]]

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.full_like(x, 7)
print(y)
# [[7 7 7]
#  [7 7 7]]

4.3 利用数值范围来创建ndarray

利用数值范围创建有着一下几种方法

• arrange() 函数：返回给定间隔内的均匀间隔的值。
• linspace() 函数：返回指定间隔内的等间隔数字。
• logspace() 函数：返回数以对数刻度均匀分布。
• numpy.random.rand() 返回一个由[0,1)内的随机数组成的数组。

import numpy as np

x = np.arange(5)
print(x)  # [0 1 2 3 4]

x = np.arange(3, 7, 2)
print(x)  # [3 5]

x = np.linspace(start=0, stop=2, num=9)
print(x)  
# [0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]

x = np.logspace(0, 1, 5)
print(np.around(x, 2))
# [ 1.    1.78  3.16  5.62 10.  ]            
                                   #np.around 返回四舍五入后的值，可指定精度。
                                   # around(a, decimals=0, out=None)
                                   # a 输入数组
                                   # decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置


x = np.linspace(start=0, stop=1, num=5)
x = [10 ** i for i in x]
print(np.around(x, 2))
# [ 1.    1.78  3.16  5.62 10.  ]

x = np.random.random(5)
print(x)
# [0.41768753 0.16315577 0.80167915 0.99690199 0.11812291]

x = np.random.random([2, 3])
print(x)
# [[0.41151858 0.93785153 0.57031309]
#  [0.13482333 0.20583516 0.45429181]]

注意：这里的**指的是乘方。

4.4 数据结构的创建

结构数组，首先需要定义结构，然后利用 numpy.array() 来创建数组，其参数 dtype 为定义的结构。

【例1】使用字典来定义结构（ 这里的names和formats都是系统自带的关键词 ）

import numpy as np

personType = np.dtype({
    'names': ['name', 'age', 'weight'],
    'formats': ['U30', 'i8', 'f8']})

a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],
             dtype=personType)
print(a, type(a))
# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# 

【例2】利用包含多个元组的列表来定义结构

import numpy as np

personType = np.dtype([('name', 'U30'), ('age', 'i8'), ('weight', 'f8')])
a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],
             dtype=personType)
print(a, type(a))
# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# 

# 结构数组的取值方式和一般数组差不多，可以通过下标取得元素：
print(a[0])
# ('Liming', 24, 63.9)

print(a[-2:])
# [('Mike', 15, 67. ) ('Jan', 34, 45.8)]

# 我们可以使用字段名作为下标获取对应的值
print(a['name'])
# ['Liming' 'Mike' 'Jan']
print(a['age'])
# [24 15 34]
print(a['weight'])
# [63.9 67.  45.8]

4.5 数组的属性

numpy自带了很多关于数组信息的方法：

• numpy.ndarray.ndim 用于返回数组的维数（轴的个数)。
• numpy.ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目。
• numpy.ndarray.size 数组中所有元素的总量，相当于数组的shape中所有元素的乘积，例如矩阵的元素总量为行与列的乘积。
• numpy.ndarray.dtype 表示ndarray 对象的元素类型。
• numpy.ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。

import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(a.shape)  # (5,)
print(a.dtype)  # int32
print(a.size)  # 5
print(a.ndim)  # 1
print(a.itemsize)  # 4

b = np.array([[1, 2, 3], [4, 5, 6.0]])
print(b.shape)  # (2, 3)
print(b.dtype)  # float64
print(b.size)  # 6
print(b.ndim)  # 2
print(b.itemsize)  # 8

注：在ndarray中所有元素必须是同一类型，否则会自动向下转换，int->float->str。

import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(a)  # [1 2 3 4 5]
b = np.array([1, 2, 3, 4, '5'])
print(b)  # ['1' '2' '3' '4' '5']
c = np.array([1, 2, 3, 4, 5.0])
print(c)  # [1. 2. 3. 4. 5.]

练习：

1.给定一系列不连续的日期序列。填充缺失的日期，使其成为连续的日期序列。

• dates = np.arange('2020-02-01', '2020-02-10', 2, np.datetime64)

import numpy as np

dates = np.arange('2020-02-01', '2020-02-10', 2, np.datetime64)
print(dates)
# ['2020-02-01' '2020-02-03' '2020-02-05' '2020-02-07' '2020-02-09']

out = []
for date, d in zip(dates, np.diff(dates)):
    out.extend(np.arange(date, date + d))
fillin = np.array(out)
output = np.hstack([fillin, dates[-1]])#加上最后一个
print(output)
# ['2020-02-01' '2020-02-02' '2020-02-03' '2020-02-04' '2020-02-05'
#  '2020-02-06' '2020-02-07' '2020-02-08' '2020-02-09']

注释：

• (1)zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b)     # 打包为元组的列表
# 得到[(1, 4), (2, 5), (3, 6)]
zip(a,c)              # 元素个数与最短的列表一致
# 得到[(1, 4), (2, 5), (3, 6)]
zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
# 得到[(1, 2, 3), (4, 5, 6)]

• (2)numpy.diff(a, n=1,axis=-1) 沿着指定轴计算第N维的离散差值。

a：输入矩阵

n：可选，代表要执行几次差值

axis：默认是最后一个

import numpy as np

A = np.arange(2 , 14).reshape((3 , 4))
A[1 , 1] = 8
print('A:' , A)
# A: [[ 2  3  4  5]
#  [ 6  8  8  9]
#  [10 11 12 13]]

print(np.diff(A,1))
# [[1 1 1]
#  [2 0 1]
#  [1 1 1]]
print(np.diff(A,2))
# [[ 0  0]
#  [-2  1]
#  [ 0  0]]

• (3)extend()与append()区别：append是将被加入的元素看作一个对象，而extend是当作一个序列。

list1 = ['a','b','c']
list2 = ['d','e','f']
list3 = list2[:]
list2.append(list1)
print(list2)
# ['d', 'e', 'f', ['a', 'b', 'c']]
list3.extend(list1)
print(list3)
# ['d', 'e', 'f', 'a', 'b', 'c']

• (4)numpy.hstack(tup) 参数tup可以是元组，列表，或者numpy数组，返回结果为numpy的数组。其主要作用就是把矩阵按水平方向叠起来，看下面的代码体会它的含义。

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

import numpy as np
a=[[1],[2],[3]]
b=[[1],[2],[3]]
c=[[1],[2],[3]]
d=[[1],[2],[3]]
print(np.hstack((a,b,c,d)))

#[[1 1 1 1]
# [2 2 2 2]
# [3 3 3 3]]

2.将本地图像导入并将其转换为numpy数组。

import numpy as np
from PIL import Image

img1 = Image.open('test.jpg')
a = np.array(img1)

print(a.shape, a.dtype)
# (959, 959, 3) uint8