Numpy学习笔记[一]
前言
1)NumPy 是 Numerical Python 的简称，是高性能计算和数据
分析的基础包;
2)NumPy是Python的一个扩充程序库。支持高级大量的维度
数组与矩阵运算，此外也针对数组运算提供大量的数学函
数库。Numpy运算效率极好,是大量机器学习框架的基础库;
注：从阿里天池学来
阿里天池学习资料
numpy官方学习资料
一、数据类型及数组创建
1、常量
(1)空值nan
1)nan、NAN、Nan写法等价；
2)各个nan值虽都是空，但不相等；
3)np.nan来赋空值
4)np.isnan()函数判断是否空；
5)np.count_nonzero()判断输入的array中有几个True；
import numpy as np
#nan、Nan、NAN写法是等价的，但各nan值不相等
x = np.array([1,1,8,np.nan,10,np.NAN,np.NaN])
print(x)
y = np.isnan(x)
print(y)
z = np.count_nonzero(y)
print(z)
#测试各个nan是否相等
print(x[3]==x[5])
print(x[3],x[5])
(2)无穷大
(1)Inf = inf = infty = Infinity = PINF等价；
(2)各inf值是相等的；
(3)np.inf来代表无穷大；
(4)np.isinf()来判断是否无穷大；
(5)np.count_nonzero()来判断输入的array有几个True；
import numpy as np
#Inf = inf = infty = Infinity = PINF等价,写各inf值也等价；
x = np.array([1,1,8,np.inf,10,np.inf,np.inf])
print(x)
y = np.isinf(x)
print(y)
z = np.count_nonzero(y)
print(z)
#测试各个inf是否相等
print(x[3]==x[5])
print(x[3],x[5])
(3) pi和e
np.pi和np.e代表圆周率和自然常数；
import numpy as np
x = np.array([1,1,8,np.e,10,np.pi,np.inf])
print(x)
2、数据类型
(1)来源
由于python数据类型比较简单，不知以应付科学计算，所以numpy新定义了几种数据类型；
(2)常见数据类型
(3)创建数据类型
numpy的数据类型是dtype对象的实例
np.dtype()来创建
eg：
(4)测试不同数据类型的数值范围
来源：
3、日期时间和时间增量
(1)日期时间
1)具体单位
2)创建方法
1)从字符串创建 datetime64 类型时，默认情况下，numpy 会根据字符串自动选择对应的单位；
2)从字符串创建 datetime64 类型时，可以强制指定使用的单位；
==Note:==常见代号，‘D’、‘W’、‘M’、‘Y’，‘h’、‘m’、's’等
3)如果一个数组，存放了不同精度的时间，会统一转化为最小时间单位，即精度最细；
4)使用arange()创建 datetime64 数组，用于生成日期范围；
3)代码
import numpy as np
a = np.datetime64('2020-04-26 20:00:05') #根据字符串自动匹配
print(a, a.dtype) # 2020-03-08T20:00:05 datetime64[s]
b = np.datetime64('2020-04-26','s') #根据二号位参数，指定日期时间格式，精度到秒。但是由粗精度到细精度，数据不准确；
print(b)
c = np.datetime64('2020-04-26 09:51','h') #根据二号位参数，指定日期时间格式，精度到小时。细精度由秒到粗精度小时，数据准确；
print(c)
#--------------------------------------------------------------------
d = np.arange('2020-08-01 20:00', '2020-08-10', dtype=np.datetime64) #用np.arange()产生指定类型数据，似乎除了两个范围外，还需要用dtype参数指定数据类型
print(d)
# ['2020-08-01T20:00' '2020-08-01T20:01' '2020-08-01T20:02' ...
# '2020-08-09T23:57' '2020-08-09T23:58' '2020-08-09T23:59']
print(d.dtype) # datetime64[m]
(2)时间增量
1)基本概念
[1]timedelta64 表示两个 datetime64 之间的差。timedelta64 也是带单位的，并且和相减运算中的两个 datetime64 中的较小的单位保持一致;
[2]生成 timedelta64时，要注意年（‘Y’）和月（‘M’）这两个单位无法和其它单位进行运算（一年有几天？一个月有几个小时？这些都是不确定的）。
2)创建方法
[1]做差：
[2]np.timedelta64()创建
3)代码
import numpy as np
a1 = np.datetime64('2020-03-08') - np.datetime64('2020-03-07')
b1 = np.datetime64('2020-03-08') - np.datetime64('2020-03-07 08:00')
c1 = np.datetime64('2020-03-08') - np.datetime64('2020-03-07 23:00', 'D')
print(a1, a1.dtype) # 1 days timedelta64[D]
print(b1, b1.dtype) # 960 minutes timedelta64[m]
print(c1, c1.dtype) # 1 days timedelta64[D]
a2 = np.datetime64('2020-03') + np.timedelta64(20, 'D')
b2 = np.datetime64('2020-06-15 00:00') + np.timedelta64(12, 'h')
print(a2, a2.dtype) # 2020-03-21 datetime64[D]
print(b2, b2.dtype) # 2020-06-15T12:00 datetime64[m]
a3 = np.timedelta64(1, 'Y')
b3 = np.timedelta64(a3, 'M')
print(a3) # 1 years
print(b3) # 12 months
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包含一组“busday”（工作日）功能。
numpy.busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)
参数roll：{'raise', 'nat', 'forward', 'following', 'backward',
numpy.is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None) Calculates which of the given dates are valid days, and which are not.
numpy.busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)Counts the number of valid days between begindates and enddates, not including the day of enddates.
1)First adjusts the date to fall on a valid day according to the roll rule, then applies offsets to the given dates counted in valid days.
2)
‘preceding’, ‘modifiedfollowing’, ‘modifiedpreceding’}
‘raise’ means to raise an exception for an invalid day.
‘nat’ means to return a NaT (not-a-time) for an invalid day.
‘forward’ and ‘following’ mean to take the first valid day later in time.
‘backward’ and ‘preceding’ mean to take the first valid day earlier in time.
3)weekmas可以通过置0置1，指定星期几为工作日。
import numpy as np
# 2021-05-07 星期五
#(1)源于numpy.busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)
#(2)offsets是偏移量，在下面两个a的赋值语句中，体现的是05.07这个星期五之后的，第一个工作日和第七个工作日；
#(3)前置要求，不适用roll参数，要求dates参数，即第一个参数是工作日
a = np.busday_offset('2021-05-07', offsets=1)
print(a) # 2021-05-10
a = np.busday_offset('2021-05-07', offsets=7)
print(a) # 2021-05-18
#（1）非工作日，要求使用roll参数往前或者往后寻找第一个工作日，非则会报错；
#（2）注意offsets偏移量这里应该置0，否则，变成寻找最接近的第offsets+1个工作日了；
a = np.busday_offset('2021-05-08', offsets=0, roll='forward')
b = np.busday_offset('2021-05-08', offsets=1, roll='forward')
print(a) # 2021-05-10
print(b) # 2021-05-11
运行结果：
②统计一个 datetime64[D] 数组中的工作日天数
核心函数：
#利用np.is_busday()判断传入的datetime64[D]数组那些天为工作日,返回值为False和True；
#利用np.count_nonzero()判断真假的个数；
#利用np.arrange生成一定数据范围内，datetime64类型的数组；
import numpy as np
# 2021-05-07 星期五
begindates = np.datetime64('2021-05-07')
enddates = np.datetime64('2021-05-31')
a = np.arange(begindates, enddates, dtype='datetime64')
#利用np.arrange生成datetime64类型的数组
b = np.count_nonzero(np.is_busday(a))
#利用np.is_busday()判断传入的datetime64[D]数组那些天为工作日,返回值为False和True
#利用np.count_nonzero()判断真假的个数
print(a)
# ['2021-05-07' '2021-05-08' '2021-05-09' '2021-05-10' '2021-05-11'
# '2021-05-12' '2021-05-13' '2021-05-14' '2021-05-15' '2021-05-16'
# '2021-05-17' '2021-05-18' '2021-05-19' '2021-05-20' '2021-05-21'
# '2021-05-22' '2021-05-23' '2021-05-24' '2021-05-25' '2021-05-26'
# '2021-05-27' '2021-05-28' '2021-05-29' '2021-05-30']
print(b) # 16
待续：holiday参数
5)datatime和datatime64的相互转换
4、数组的创建
(1)简介
(1)numpy 提供的最重要的数据结构是ndarray，它是 python 中list的扩展;
(2)NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
n代表n个
d代表dimensions维度
(2)一般创建方法
1)通过array()函数进行创建
输入数据可以是列表、元组等
def array(p_object, dtype=None, copy=True, order='K', subok=False, ndmin=0):
a）一维数组
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'>
b)二维数组
# 创建二维数组 输入数据为列表的列表
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'>
c)三维数组
# 创建三维数组 输入数据为列表的列表的元组，当然也可以是列表
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'>
2)通过asarray()函数进行创建
(1)浅层拷贝，直接复制成新ndarray对象，与之前独立;
(2)array()和asarray()的区别。当数据源是ndarray 时，array()仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 asarray()不会;
import numpy as np
#example 1:
data1=[[1,1,1],[1,1,1],[1,1,1]]#python自带的列表类型，列表带列表；
print(type(data1))
arr2=np.array(data1)
arr3=np.asarray(data1)
data1[1][1] = 2
print('data1:\n',data1)
print('arr2:\n',arr2)
print('arr3:\n',arr3)
# example 2:
arr1=np.ones((3,3))#numpy中的ndarry类型
print(type(arr1))
arr2=np.array(arr1)
arr3=np.asarray(arr1)
arr1[1]=2
print('arr1:\n',arr1)
print('arr2:\n',arr2)
print('arr3:\n',arr3)
结果：
3)通过fromfunction()函数进行创建
1)函数介绍
def fromfunction(function, shape, **kwargs):
[1]第二个参数既指定了生成的数组行列数，也指定了x，y的索引范围；
[2]eg:5，代表x从0-4,五个数，4，代表y从0-3四个数；
2)用途
[1]定义一个函数，让每一个坐标都执行该函数，来创建数组；
[2]函数考研用lambda表达式来定义，函数式编程；
# example 3: .fromfunction创建
import numpy as np
def f(x, y):#参数有x和y要完成二位数组创建
return 10 * x + y
x = np.fromfunction(f, (5, 4), dtype=int)
#第二个参数既指定了生成的数组行列数，也指定了x，y的索引范围
#eg:5，代表x从0-4,五个数，4，代表y从0-3四个数
print(x)
print('\n')
x = np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
#都是从0-2，三个数，三行三列的二维数组
print(x)
print('\n')
x = np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
print(x)
#都是从0-2，三个数，三行三列的二维数组
(3)、特殊数组创建方法
1)零数组、1数组、空数组、常数数组
1)zeros()函数：返回给定形状和类型的零数组。
2)zeros_like()函数：返回与给定数组形状和类型相同的零数组。
def zeros(shape, dtype=None, order='C'):
def zeros_like(a, dtype=None, order='K', subok=True, shape=None):
3)ones()函数：返回给定形状和类型的1数组。
4)ones_like()函数：返回与给定数组形状和类型相同的1数组。
def ones(shape, dtype=None, order='C'):
def ones_like(a, dtype=None, order='K', subok=True, shape=None):
4)empty()函数：返回一个空数组，数组元素为随机数。
5)empty_like函数：返回与给定数组具有相同形状和类型的新数组
def empty(shape, dtype=None, order='C'):
def empty_like(prototype, dtype=None, order='K', subok=True, shape=None):
为什么空数组里面的元素是随机的？
6)full()函数：返回一个常数数组。
7)full_like()函数：返回与给定数组具有相同形状和类型的常数数组。
def full(shape, fill_value, dtype=None, order='C'):
def full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None):
例子
2)单位数组、对角数组、常数数组
1)eye()函数：返回一个对角线上为1，其它地方为零的单位数组。
2)identity()函数：返回一个方的单位数组。
def eye(N, M=None, k=0, dtype=float, order='C'):
def identity(n, dtype=None):
3)diag()函数：提取对角线或构造对角数组。
def diag(v, k=0):
3)利用数值范围来创建ndarray
1)arange()函数：返回给定间隔内的均匀间隔的值。
2)linspace()函数：返回指定间隔内的等间隔数组。
3)logspace()函数：返回数以对数刻度均匀分布。
4)numpy.random.rand() 返回一个由[0,1)内的随机数组成的数组。
def arange([start,] stop[, step,], dtype=None):
def linspace(start, stop, num=50, endpoint=True, retstep=False,
dtype=None, axis=0):
def logspace(start, stop, num=50, endpoint=True, base=10.0,
dtype=None, axis=0):
def rand(d0, d1, ..., dn):
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]#10的i次方 #函数式编程？？？
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)结构数组创建
1）利用字典来定义结构
2）利用包含多个元组的列表来定义结构
import numpy as np
#example 1
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))
print(type(a[0][0]))
print(a['name'])
#example 2
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))
print(a[0])
print(a['name'])
print(a['age'])
print(a['weight'])
5、数组的属性
1)numpy.ndarray.ndim用于返回数组的维数（轴的个数）也称为秩，一维数组的秩为 1，二维数组的秩为 2，以此类推。
2)numpy.ndarray.shape返回一个元组，这个元组的长度就是维度的数目,且表示出行列数信息；
3)numpy.ndarray.size数组中所有元素的总量，相当于数组的shape中所有元素的乘积，例如矩阵的元素总量为行与列的乘积。
4)numpy.ndarray.dtype ndarray对象的元素类型。
5)numpy.ndarray.itemsize以字节的形式返回数组中每一个元素的大小。
class ndarray(object):
shape = property(lambda self: object(), lambda self, v: None, lambda self: None)
dtype = property(lambda self: object(), lambda self, v: None, lambda self: None)
size = property(lambda self: object(), lambda self, v: None, lambda self: None)
ndim = property(lambda self: object(), lambda self, v: None, lambda self: None)
itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None)
280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
