python数据分析——numpy基础（相关方法以及具体操作）

1、基本函数

np.arange()

np.ones() np.ones_like()

np.zeros() np.zeros_like()

np.empty() np.empty_like()

np.eye() np.identity()

np.diag

np.linspace()

np.logspace()

1、np.arange()

# arange()方法与python中的range()函数一致
# 创建一个范围数组
np1 = np.arange(5)
print(np1)
np2 = np.arange(0, 100, 2)
print(np2)

2、np.ones np.ones_like

# np.ones   np.ones_like
n1 = np.ones(4)  # 方法里一个值代表一位数组的元素个数
print(n1)
n2 = np.ones((3, 4))  # 元组括起来之后分别表示行列数
print(n2)
# 创建一个像np2数组结构的数据，里面的元素都是1
n3 = np.ones_like(np2)
print(n3)

3、np.zeros np.zeros_like

# np.zeros   np.zeros_like
# 两个函数效果，及用法与ones一致
n1 = np.zeros(3)
print(n1)
n2 = np.zeros((2, 4))
print(n2)
n3 = np.zeros_like(np1)
print(n3)

4、np.empty   np.empty_like

# np.empty   np.empty_like
n = np.array([1,2,3,4])
n1 = np.empty(3)
print(n1)
n2 = np.empty((2, 3))
print(n2)
n3 = np.empty_like(n)
print(n3)

5、np.eye np.identity

# 创建一个对角线为1的4×4的数组
# 如果说想要改一个对角线的话可以通过k参数进行设置
n1 = np.eye(4)
print(n1)
n1 = np.eye(4, k = 1)
print(n1)
n1 = np.eye(3, 4)
print(n1)
n2 = np.identity(3)
print(n2)

np.identity()的详解
产生的数组将会是一个正方形的数组

np.eye()的详解
如果只传参数N的话，那么就会产生一个由N参数（行数）控制的一个正方形的数组
如果传入参数N和M的话，如果N==M那么就会产生一个正方形的数组，如果N!=M，那么就会产生一个N行M列的数组

6、np.diag()
创建一个以指定元素为对角线元素的数组，参数k可以控制对角线的位置，>0向右上角移动，<0向左下角移动

n1 = np.diag([1,2,3,4,5])
print(n1)
n1= np.diag([1,2,3, 4], k = -2)
print(n1)

7、np.linspace()

产生一个由参数指定范围的平均数组
结束位置的12是包含的

n1 = np.linspace(1, 12, 4)
print(n1)

8、np.logspace()

创建一个由base^ start到 base ^ stop范围的一个平均数组
默认的base是10

n1 = np.logspace(2, 3, num = 4)
print(n1)

---

2、基本的属性

dtype	返回数组中元素的类型
shape	返回由整数组成的元组，元组中的每个整数依次对应数组的每个轴的元素个数
size	返回一个整数，代表数组中元素的个数
ndim	返回一个整数，代表数组的轴的个数，即维度
nbytes	返回一个整数，代表用于保存数据的字节数

import numpy as np
# 返回数组中的元素类型
d = np.array([1,2,3,4,5])
print(d.dtype)

# astype()修改原来元素的数据类型的元素
# 但是这个操作只是复制了一个数组而已，
# 并不是直接去修改数组里面的类型
res = d.astype(float)
print(res)
print(d.dtype)

# shape 表示数组的形状
d1 = np.arange(20).reshape((4, 5))
print(d1)
print(d1.shape)

# size 返回一个整数，代表数组中的元素个数
print(d1.size)

# ndim  返回一个整数，代表数组的轴的个数
print(d1.ndim)

# nbytes  返回一个整数，代表用于保存数据的字节数
print(d1.nbytes)

运行结果:

---

3、数组的索引和切片

数组索引

1、下标是整数

# 可以直接通过下标获取，而且这里面的数据可以被修改
n1 = np.array([1,2,34,5])
print(n1,'直接通过下标获取',n1[2],sep = '\n')
n1 = np.arange(20).reshape((4, 5))
print(n1, '直接通过下标获取', n1[2][1], sep = '\n')
print('也可以通过这种方式n1[1,2]', n1[1,2])

运行结果：

2、下标是列表

# 下标是一个列表，表示取第几行
n1 = np.logspace(2, 3, 12).reshape((3,4))
print(n1, '下标是一个列表', n1[[0, 2]], sep = '\n')

# 如果下标是一个二维列表
# [0, 2], [1, 1] 表示二维列表中第0行和第1列的元素
# 表示第2行和第1列的元素
# 是列表的0轴和1轴结合
print('下标[[0, 2], [1, 1]]', n1[[0,2], [1,1]], sep = '\n')

# 也可以利用下标是列表的情况来调换顺序，组成一个新的列表
print('利用下标是列表，来调换顺序，组成新列表', n1[[2,0,1]],sep = '\n')

# 列表中的元素可以重复，按照原来数组中的元素组成一个新的数组
print('列表中的元素可以重复，按照原来数组中的元素组成一个新的数组', n1[[2, 0, 0, 1]], sep = '\n')

3、下标是数组

# 下标是数组
# 数组的获取实际上和列表的获取是类似的
n1 = np.arange(12).reshape((3, 4))  # 二维列表
print(n1)
a = np.array([2, 0, 1])  # 数组里面的元素表示原数组的行数
print(n1[a])

# 一维列表
n1 = np.array([11, 22, 33, 44, 55])
# 下标是数组，按照数组中的元素值作为原数组的下标进行提取
print(n1[a])

# 以数组为下标的便捷之处
# 可以直接判断数组中的元素是几
# 举个例子，我要判断二维列表中的偶数
n2 = np.arange(12).reshape((3, 4))
print(n2)
check = n2 % 2 == 0
print(check)
# 根据这个作为原来二维数组的筛选条件
print(n2[check])

数组切片

# 数组切片
# 创建一维数组
n1 = np.arange(30, 50, 2)
print(n1)
print('切片处理', n1[2:8])

# 创建二维数组
n2 = np.arange(0, 60, 10).reshape(-1, 1) + np.arange(0, 6)
print(n2)
# 一个切片操作
print('一个切片操作，表示切分行数', n2[2:4], sep = '\n')
# 两个切片操作
# 第一个是代表0轴范围，第二个代表1轴范围，规定一个二维区域
print('两个切片操作', n2[1:3, 2:5], sep = '\n')
# 切片的start,stop,step和列表切片的三个量是一致的
print(n2[:3, 2:])
print(n2[::2, ::2])

---

4、数组的常用操作

np.reshape	ndarray.reshape
ndarray.shape
ndarray.flatten()	ndarray.ravel

1、变形

reshape

# reshape()
n1 = np.arange(12).reshape((3,4))
print('直接在创建数组时就调用reshape', n1, sep ='\n')
n2 = np.arange(10)
n3 = np.reshape(n2, (2, 5))
print('创建了数组再调用reshape', n3, sep = '\n')

# 特殊情况
# 当不清楚有多少数据的时候，第一个值可以写-1,第二个值的数字控制列数
n4 = np.logspace(3, 4, 15).reshape(-1, 3)
print('reshape第一个参数是-1',n4, sep = '\n')

n5 = np.linspace(2, 10, num = 5).reshape(5,)
print(n5)
n6 = np.linspace(2, 10 ,num = 4).reshape((1, 4))
print(n6)

flatten()

# flatten()  变平
n7 = n6.flatten()
print(n7)

ravel()

# ravel()
n = np.arange(30, 18 , -2).reshape((2, 3))
print(n)
n8 = np.ravel(n)  # 扁平
print(n8)
n9 = np.array([[3,1,4], [5, 9, 0]])
n10 = n9.ravel()
print(n10)

使用切片来进行变形

# 通过切片来改变形状
n1 = np.arange(5)
print(n1)
print(n1[:, np.newaxis])
# np.newaxis相当于None
print(n1[::2, None])

2、组合

水平组合	np.hstack	np.concatenate
垂直组合	np.vstack	np.concatenate

注意：不论是水平组合还是垂直组合，都要保证对应的行列数是一致的，水平组合：两个数组的行数要一致；垂直组合：两个数组的列数要一致

水平组合

a = np.arange(9).reshape(3,3)
print(a)
b = np.arange(15).reshape((3, 5))
print(b)
# 使用np.hstack()进行水平组合
new = np.hstack((a,b))
print(new)
# 也可以使用np.concatenate进行轴的设置，实现水平组合
new1 = np.concatenate((a, b), axis = 1)
print(new1)

垂直组合

# 使用np.vstack()进行垂直组合
n1 = np.vstack((a, b.T))
print(n1)
# b.T的操作是将一个数组进行转置
print('转置前', b, sep = '\n')
print('转置后', b.T, sep = '\n')
# 使用np.concatenate进行垂直组合
n2 = np.concatenate((a, b.T), axis = 0)
print(n2)

3、分割

np.split

np.hsplit

np.vsplit

np.split()
axis = 1 水平切割

n = np.arange(16).reshape(4, 4)
print('分割前', n , sep = '\n')

# 调用np.split()方法切割
res_n = np.split(n, 2, axis = 1)
print('使用np.split()切割，沿着1轴', res_n, sep = '\n')

np.hsplit()

#调用np.hsplit()进行水平切割
res_n = np.hsplit(n, 2)
print('使用np.hstack()水平切割', res_n, sep = '\n')

np.vsplit()
垂直切割

# 调用np.vsplit()垂直切割
res_n = np.vsplit(n, 2)
print('使用np.vsplit()垂直切割', res_n, sep = '\n')

---

5、数组运算

1、四则运算

# 一维数组四则运算
a = np.arange(3)
print('数组a', a)
b = np.array([3, 4, 5])
print('数组b', b)
# 事例：加法
# 其他运算同理
a = a + 10
print('数组a加10', a)
b = a + b
print('数组a+数组b', b)
a = a ** 2
print('数组a平方', a)

一维数组与二维数组运算
相当于一个广播

# 一维数组与二维数组运算
a = np.arange(5)
b = np.arange(10).reshape(2, 5)
print('数组a', a)
print('数组b', b, sep = '\n')
# a + b
print('数组a+数组b', a+b, sep = '\n')

b = np.arange(10).reshape(2, 5)
print('数组b', b, sep = '\n')
c = np.arange(2, 4).reshape(-1, 1)
print('数组c', c, sep = '\n')
# 数组b+数组c
print('数组b+数组c', b+c, sep = '\n')

2、比较运算

需要注意的是，在做数组比较的时候，两个数字的形状要一致

a = np.array([3, 6, 0])
b = np.array([4, 2, 9])
print('数组a、数组b做比较运算', a > b, sep = '\n')

3、逻辑运算

由于numpy是python中的一个库，所以逻辑运算不能直接使用python 中的and、or、not了
要换成logical_or、logical_and、logical_not

a = np.array([True, False])
b = np.array([False, True])
res = np.logical_or(a, b)
print('logical_or的结果', res)
res1 = np.logical_and(a, b)
print('logical_and的结果', res1)
res2 = np.logical_not(a)
print('logical_not的结果', res2)

如果想要实现a < b and b > a类似这种操作的内容
可以使用np.any()或者np.all()

np.any()

np.all()

a = np.array([3, 8, 0])
b = np.array([4, 6, 3])
res1 = np.any(a<b)
print('只要满足一个a<b，那么就返回True:np.any()', res1, sep = '\n')
res2 = np.all(a>b)
print('所有的元素都满足a>b，才会返回True:np.all()', res2, sep = '\n')
res3 = np.any(a<b) and np.all(a<b)
print(res3)
res4 = np.any(a<b) or np.all(a<b)
print(res4)

---

6、数组的通用函数

函数名称	解释
np.sin; np.cos; np.tan	三角函数
np.arcsin; np.arccos; np.arctan	反三角函数
np.sinh; np.cosh; np.tanh	双曲三角函数
np.arcsinh; np.arccosh; np.arctanh	反双曲三角函数
np.sqrt	求平方根
np.exp	计算自然指数
np.log; np.log2; np.log10	计算对数(依次以e、2、10为底)

函数名称(二元函数)	解释
np.add; np.subtract; np.multiply; np.divide	算数运算函数
np.equal; np.not_equal; np.less; np.less_equal; np.greater; np.greater_equal	比较运算函数
np.power	指数运算
np.remainder	得到余数
np.reciprocal	返回倒数（不能使用整数型）
np.real; np.imag; np.conj	复数的实部、虚部和完整的复数
np.sign; np.abs	得到对象符号和绝对值
np.floor; np.ceil; np.rint	效果都是取整
np.round	四舍五入

以np.sin为例
利用matplolib绘制一个正弦函数
代码如下：

import matplotlib.pyplot as plt
import numpy as np

alpha = np.linspace(-1, 1, num = 30)
res = np.sin(np.pi * alpha)
print(res)
plt.figure(figsize = (8, 6))
plt.plot(alpha, res)
plt.style.use('ggplot')
plt.show()

通用函数有很多，但是有的时候我们需要自己写函数，而一般的函数在传参的时候是无法去处理数组的，这就需要我们进行一个转换了

例如一个处理BMI指数的函数
准备一个函数，但是在传参的时候两个参数是数组

def BMI(weight, height):
	res = weight / height ** 2
	if res >= 28:
		return 2
	elif 24 <= res <= 27.9:
		return 1
	elif 18.5 <= res <= 23.9:
		return 0
	elif res <= 18.4:
		return -1
w = (95 - 45) * np.random.random_sample(10, ) + 45
w = np.round(w, 2)
print(w)
h = (2.1 - 1.5) * np.random.random_sample(10, ) + 1.5
h = np.round(h, 2)
print(h)
res = BMI(w, h)
print(res)

这种情况下直接去运行的话是会报错的，没有办法处理数组

在这分别解释一下np.round()和np.random.random_sample()
np.round()就是起到一个保留小数位的功能，第一个参数是数组，第二个参数是你想保留的位数
np.random.random_sample()，产生0-1之间的随机浮点数的数组，参数值代表生成的个数

解决方法：将这个函数转换成一个通用函数
使用np.frompyfunc()方法

frompyfunc(func, nin, nout)

Takes an arbitrary Python function and returns a NumPy ufunc.

Can be used, for example, to add broadcasting to a built-in Python
function (see Examples section).

Parameters
----------
func : Python function object
    An arbitrary Python function.
nin : int
    The number of input arguments.
nout : int
    The number of objects returned by `func`.

意思就是第一个参数是自己创建的python的函数，第二个参数是这个函数需要传入几个参数，第三个参数表示返回值个数是几个

def BMI(weight, height):
	res = weight / height ** 2
	if res >= 28:
		return 2
	elif 24 <= res <= 27.9:
		return 1
	elif 18.5 <= res <= 23.9:
		return 0
	elif res <= 18.4:
		return -1
w = (95 - 45) * np.random.random_sample(10, ) + 45
w = np.round(w, 2)
print('保留两位小数的体重', w)
h = (2.1 - 1.5) * np.random.random_sample(10, ) + 1.5
h = np.round(h, 2)
print('保留两位小数的身高', h)
res = np.frompyfunc(BMI, 2, 1)
res = res(w, h)
print('得出的结果',res)