Nump基础学习_常量、数据类型、时间日期和时间增量和创建数组

最新推荐文章于 2023-09-04 16:26:40 发布

小数learning

最新推荐文章于 2023-09-04 16:26:40 发布

阅读量801

点赞数

文章标签： python numpy 数据分析

本文链接：https://blog.csdn.net/weixin_48353010/article/details/109158999

版权

1.常量

	主要介绍了nan、inf、pi和e四种类型
	1、nan表示空值，是float类型，不能用作计算
	2、inf、pi和e使用方法类似

1.1 numpy.nan

1、空值的表示方法有三种：nan、NaN、NAN
2、np.nan是一个float类型的数据，不能用作计算，
     都无法得到数字，返回值都是nan。
3、两个空值不相等，判断是否为空返回的是布尔型

1、nan不能参与计算

a=np.nan+2  
print(a)

输出结果为：nan

2、两个空值不相等

import numpy as np
print(np.nan == np.NaN) 
print(np.nan != np.NAN)

输出结果为：False
          True

3、数组中含有np.nan的返回值为nan

import numpy as np
x = np.array([1, 1, 8, np.nan, 10])
print(x)

输出结果为：[ 1.  1.  8. nan 10.]

4、判断是否为空值（返回值为True或False）

y = np.isnan(x)
print(y)

输出结果为：[False False False  True False]

5、count_nonzero()统计不为空值的个数

#返回的是y中非0元素的个数
z = np.count_nonzero(y)

输出结果为：1

1.2 正无穷大

有四种表示：Inf = inf = infty = Infinity = PINF

import numpy as np
np.Inf

输出结果为：inf

1.3.圆周率（pi）

np.pi

输出结果为：3.141592653589793

1.4自然对数（e）

np.e

输出结果：2.718281828459045

2.数据类型

2.1常见数据类型

numpy 支持的数据类型比 Python 内置的类型要多很多，其中部分
类型	对应为 Python 内置的类型用_标出，下表列举了常用 numpy
 基本类型。

类型	备注	说明
bool_ = bool8	8位	布尔类型
int8 = byte	8位	整型
int16 = short	16位	整型
int32 = intc	32位	无符号整型
int_ = int64 = long = int0 = intp	64位	整型
uint8 = ubyte	8位	无符号整型
uint16 = ushort 16位	无符号整型
uint64 = uintp = uint0 = uint 64位	无符号整型
float16 = half	16位	浮点型
float32 = single	32位	浮点型
float_ = float64 = double	64位	浮点型
str_ = unicode_ = str0 = unicode	Unicode	字符串
datetime64		日期时间类型
timedelta64		表示两个时间之间的间隔

2.2创建数据类型

    	    numpy 的数值类型实际上是 dtype 对象的实例。

每个内建类型都有一个唯一定义它的字符代码，如下表所示：

类型	备注	说明
b	boolean	‘b1’
i	signed integer	‘i1’, ‘i2’, ‘i4’, ‘i8’
u	unsigned integer	‘u1’, ‘u2’ ,‘u4’ ,‘u8’
f	floating-point	‘f2’, ‘f4’, ‘f8’
c	complex floating-point
m	timedelta64	表示两个时间之间的间隔
M	datetime64	日期时间类型
O	object	浮点型
S	(byte-)string	S3表示长度为3的字符串
U	Unicode	字符串
V	void

数据类型对象 (dtype)

1、数据的类型（整数，浮点数或者 Python 对象）
2、数据的大小（例如， 整数使用多少个字节存储）
3、数据的字节顺序（小端法或大端法）

例如可以使用 ‘i1’, ‘i2’,‘i4’,‘i8’ 代替int8, int16, int32, int64 四种数据类型

import numpy as np
dt = np.dtype('i4')
print(dt)
print(dt.itemsize) #输出字节大小

输出结果为：int32
	       4

2.3数据类型信息

1、Python 的浮点数通常是64位浮点数，几乎等同于 np.float64 。
2、NumPy和Python整数类型的行为在整数溢出方面存在显著差异，
   与 NumPy 不同，Python 的 int 是灵活的。这意味着Python
   整数可以扩展以容纳任何整数并且不会溢出。

import numpy as np
ii16 = np.iinfo(np.int16)
print(ii16.min) 
print(ii16.max)

运行结果：-32768
         32767

3.时间日期和时间增量

3.1 datetime64 基础

  在 numpy 中，我们很方便的将字符串转换成时间日期类型 
  datetime64，datatime64 是带单位的日期时间类型

import numpy as np
a = np.datetime64('2020-03-08 20:00:05')
print(a, a.dtype)#输出时显示其时间最小单位

  输出结果：2020-03-08T20:00:05 datetime64[s]

1、从字符串创建 datetime64 类型时，可以强制指定使用的
单位。如下：

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

1、如果两个 datetime64 对象具有不同的单位，它们可能仍然
 代表相同的时刻。并且从较大的单位（如月份）转换为较小的单位
（如天数）是安全的
2、2019-03 和 2019-03-01 所表示的其实是同一个时间，虽然指定
的单位不同

2、从字符串创建 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]

3、使用 arange() 创建 datetime64 数组，用于生成日期范围
（步长默认为最小单位值）

import numpy as np
a = np.arange('2020-08-01', '2020-08-10', dtype=np.datetime64)
print(a)
# 
# '2020-08-06' '2020-08-07' '2020-08-08' '2020-08-09']
print(a.dtype) # datetime64[D]

输出结果：['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']
        datetime64[D]

3.2 datetime64 和 timedelta64 运算

1、timedelta64 表示两个 datetime64 之间的差。
timedelta64也是带单位的，并且和相减运算中的
两个 datetime64 中的较小的单位保持一致。

import numpy as np
a = np.datetime64('2020-03-08') - np.datetime64('2020-03-07')
b = np.datetime64('2020-03-08') - np.datetime64('202-03-07 08:00')
c = np.datetime64('2020-03-08') - np.datetime64('2020-03-07 23:00', 'D')
print(a, a.dtype) # 1 days timedelta64[D]
print(b, b.dtype) # 956178240 minutes timedelta64[m]
print(c, c.dtype) # 1 days timedelta64[D]

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
c = np.timedelta64(1, 'h')
d = np.timedelta64(c, 'm')
print(c) # 1 hours
print(d) # 60 minutes

print(np.timedelta64(a, 'D'))
#TypeError: Cannot cast NumPy timedelta64 scalar from metadata [Y] to [D] according to the rule 'same_kind'

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

3.3 datetime64 的应用

为了允许在只有一周中某些日子有效的上下文中使用日期时间，
NumPy包含一组“busday”（工作日）功能。

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

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
a = np.busday_offset('2020-07-11', offsets=0, roll='forward')
b = np.busday_offset('2020-07-11', offsets=0, roll='backward')
print(a) # 2020-07-13
print(b) # 2020-07-10
a = np.busday_offset('2020-07-11', offsets=1, roll='forward')
b = np.busday_offset('2020-07-11', offsets=1, roll='backward')
print(a) # 2020-07-14

可以指定偏移量为 0 来获取当前日期向前或向后最近的工作日，当然，
如果当前日期本身就是工作日，则直接返回当前日期。

2、返回指定日期是否是工作日

import numpy as np
# 2020-07-10 星期五
a = np.is_busday('2020-07-10')
b = np.is_busday('2020-07-11')
print(a) # True
print(b) # False

3、统计一个 datetime64[D] 数组中的工作日天数

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

4、自定义周掩码值，即指定一周中哪些星期是工作日

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

5、返回两个日期之间的工作日数量

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

4 数组的创建

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

4.1依据现有数据来创建 ndarray

4.1.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] <class 'numpy.ndarray'>
print(b, type(b))
# [0 1 2 3 4] <class 'numpy.ndarray'>

创建二维数组

c = np.array([[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25],
[26, 27, 28, 29, 30],
[31, 32, 33, 34, 35]])
print(c, type(c))
# [[11 12 13 14 15]
# [16 17 18 19 20]
# [21 22 23 24 25]
# [26 27 28 29 30]
# [31 32 33 34 35]] <class 'numpy.ndarray'>

# 创建三维数组
d = np.array([[(1.5, 2, 3), (4, 5, 6)],
[(3, 2, 1), (4, 5, 6)]])
print(d, type(d))
#[[[1.5 2.  3. ]
 # [4.  5.  6. ]]

# [[3.  2.  1. ]
  #[4.  5.  6. ]]] <class 'numpy.ndarray'>

4.1.2 （b）通过asarray()函数进行创建

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

import numpy as np
x = [[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))
#[[1, 1, 1], [1, 1, 2], [1, 1, 1]] <class 'list'>

print(y,type(y))
#[[1 1 1]
 #[1 1 1]
 #[1 1 1]] <class 'numpy.ndarray'>

print(z,type(z))
#[[1 1 1]
 #[1 1 1]
 #[1 1 1]] <class 'numpy.ndarray'>

 array() 和 asarray() 的区别。
  array()和 asarray()主要区别就是当数据源是ndarray时,
  array() 仍然会 copy 出一个副本，占用新的内存，但不改变
  dtype 时 asarray() 不会。

import numpy as np
x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
y = np.array(x)
z = np.asarray(x)
w = np.asarray(x, dtype=np.int)
x[1][2] = 2
print(x,type(x),x.dtype)
# [[1 1 1]
# [1 1 2]
# [1 1 1]] <class 'numpy.ndarray'> int32

print(y,type(y),y.dtype)
# [[1 1 1]
# [1 1 1]
# [1 1 1]] <class 'numpy.ndarray'> int32

print(z,type(z),z.dtype)
# [[1 1 1]
# [1 1 2]
# [1 1 1]] <class 'numpy.ndarray'> int32

print(w,type(w),w.dtype)
# [[1 1 1]
# [1 1 2]
# [1 1 1]] <class 'numpy.ndarray'> int32

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

import numpy as np
x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
print(x, x.dtype)
# [[1 1 1]
# [1 1 1]
# [1 1 1]] int32

x.dtype = np.float
# ValueError: When changing to a larger dtype, its size must be a divisor of the total size in bytes of the last
axis of the array.

4.1.3 （c）通过fromfunction()函数进行创建

给函数绘图的时候可能会用到 fromfunction() ，该函数可从函数
中创建数组

1、通过在每个坐标上执行一个函数来构造数组。

import numpy as np
def f(x, y):
return 10 * x + y
x = np.fromfunction(f, (5, 4), dtype=int)
print(x)
# [[ 0 1 2 3]
# [10 11 12 13]
# [20 21 22 23]
# [30 31 32 33]
# [40 41 42 43]]

x = np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
print(x)
# [[ True False False]
# [False True False]

4.2 依据 ones 和 zeros 填充方式

4.2.1 （a）零数组

zeros() 函数：返回给定形状和类型的零数组。
zeros_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]]

4.2.2 （b）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]]

4.2.3 （c）空数组

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.2.4 （d）单位数组

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.]]

4.2.5 （e）对角数组

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]]

4.2.6 （f）常数数组

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

arange() 函数：返回给定间隔内的均匀间隔的值。
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. 
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]]

np.around 返回四舍五入后的值，可指定精度。
around(a, decimals=0, out=None)
a 输入数组
decimals 要舍入的小数位数。 默认值为0。 如果为负，
整数将四舍五入到小数点左侧的位置

4.4字典

4.4.1 (a)利用字典来定义结构

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)]
# <class 'numpy.ndarray'>

4.4.2 （b）利用包含多个元组的列表来定义结构

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)]
# <class 'numpy.ndarray'>
# 结构数组的取值方式和一般数组差不多，可以通过下标取得元素：
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]

小数learning

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Nump基础学习_常量、数据类型、时间日期和时间增量和创建数组

这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入欢迎使用Markdown编辑器你好！这是你第一次使用 Markdown编辑器所展示的欢迎页。如果你想学习如何使用Mar
复制链接

扫一扫