python数据分析笔记--numpy

数据分析就业班

前言

1. 创建虚拟环境

conda create -n 环境名称 python版本号

2. 删除虚拟环境

conda remove -n 环境名称 --all

3. 进入虚拟环境

source activate 环境名称

数组（ndarray)：学习库numpy

import numpy as np

1. 创建一个数组

1.1一个一维数组

a = np.array([1,2,3,4])
# print(a)

1.2创建一个多维数组

# 数组要求矩阵维度是一致的，但是列表c没有强制要求
b = np.array([[1,2,3,4],[2,3,4,5]])
# print(b)
c=np.array([[1,2],[2,3,4,5]])
# print(c)

1.3数组可以通过arange来指定数组的区间，可以设置步长，步长可以是小数

d=np.arange(1,10)
# print(d)

1.4数组全为1

# shape指定每个维度的大小,5行6列
e=np.ones(shape=(3,4))

1.5指定数组类似于其他矩阵得形状

f=np.ones_like(e)
# print(f)

1.6创建全为0的数组

g=np.zeros(shape=(3,4))
# print(g)
h=np.zeros_like(d)
# print(h)

1.7empty

# 创建一个数组，没有初始化的数组,初始值是不确定的,随机产生的数，数值没有意义，只是占个地方
i=np.empty(shape=(3,4,2))
#print(i)
j=np.empty_like(np.array([[2,2],[11,4]]))
# print(j)

1.8用户创建一个数组

形状由第一个参数指定(3,4)，填充值由第二个参数指定100
k=np.full((3,4),100)
# print(k)
np.full_like(np.array([[2,2],[11,4]]),300)

1.9单位矩阵

# 创建指定长度的矩阵
l=np.eye(5)
# print(l)

1.10创建等差数列

# 1到50之间的等差数列，endpoint=False表示不包括50,是否包含终止点
m=np.linspace(1,50,3,endpoint=False)
# print(m)

1.11创建等比数列

指数上等差，其实就是等比数列,比等差数列多一个base=10（默认）

n=np.logspace(1,10,2,base=10)
print(n)
# arange 和linspace都可以创建等差数列，arange关注步长，linspace侧重于多少个元素

数组要求元素类型一致，列表不要求类型一致

2. 数组的4个相关属性

a=np.array([[1,2,3],[1,2,2],['3',12,2]])
```python
# ndim返回数组的维度
print(a.ndim)
# shape返回数组的形状
print(a.shape)
# 返回数组元素的类型，数组类型一致
print(a.dtype)
# 返回数组中元素的个数(最低维元素的个数）
print(a.size)
# 每个元素占用空间的大小
print(a.itemsize)
# 创建数组时合一指定数组的类型，dtype指定，如果没有指定用则根据元素自动推断
a=np.array([[1,2,3],[1,2,2]],dtype=np.int64)
print(a.dtype)
# '3'表示字符串，摆放位置不同，占用的地方大小也不同
# a:知道时字符串所谓分配的类型就是U1，b:一开始是整数，分配的类型是int32，等遇到字符串时才变成U1
a=np.array(['3',1,2])
print(a.dtype)
b=np.array([1,2,'3'])
print(b.dtype)

2.1类型转换

# 使用数据对象的astype进行转换,不改变原来的,改变后的结果要赋值重新输出
# 改成整数
a=np.array([1.0,1,2,3.2])
b=a.astype(np.int32)
print(b)

2.2不能使用dtype进行类型转换，因为不同类型的数据存储方法不同，可能溢出

3. 改变形状

3.1两种调用方法

1. b:np.方法名（）
2. c:数组对象.方法名（）, 其中a是数组对象

a=np.arange(24)
b=np.reshape(a,(3,8))
c=a.reshape(4,6)

3.2如果改变形状是多维，可以将一个维度设置为-1，则数据长度自动计算

d=np.reshape(a,(6,-1))
print(d)
e=np.reshape(a,(-1,1))
print(e)

4. 索引

4.1 多维数组的索引

1. 第一个索引位置是0
2. 多维数组索引由两种方式：a[0][1]或者a[0,1]

import numpy as np
a=np.arange(10)
a=a.reshape([2,5])
print(a)
print(a[0][3])
print(a[1,4])

5.切片

b=np.arange(30).reshape(5,6)
#可以先切高维，再切次高维，中间加逗号
print(b[1:4,1:4])
c=np.arange(10)
print(c)
print(c[1:5:2])
# 2表示增量,不包含末位数

5.1 对于np.array切片返回的是原数组的视图，*共享 *底层数据，相当于汇编中指向一个地址中的内容，可以减少工作量

b=np.array([0,10,2,3])
a=b[:]
a[0]=100
print(b)

5.2 实现内容的拷贝，使用copy

a=np.array([0,1,12,23])
b=a.copy()
b[0]=1000
print(a)
print(b)

5.3通过整数数组进行索引(3种方式）

通过正式进行索引提取元素返回的是原数组的拷贝，而不是视图

a=np.array([1,2,23,2,1,212,122])
a[1],a[3],a[4]
c=a[[1,3,4]]
print(c)
index=[1,3,4]
b=a[index]
print(b)

5.4通过整数数组提取多维数组

a=np.arange(24).reshape(2,3,4)
print(a)
print(a[[1,0]])
print(a[0,1,1],a[1,1,1])
print(a[[1,0],[1,0],[1,0]])

5.5 通过布尔数组进行索引

bool_array=[True,True,False,True,False]
a=np.array([1,21,232,2,223])
# print(a[bool_array])

上面这种不用
下面的方法是计算产生布尔数组后，使用该布尔数组取索引原数组得到符合条件的数组（过滤）布尔类型只有True或False

age=np.array([30,29,15,23,10,34,18])
bool_array = age > 15
print(age[bool_array])
print(bool_array)
print(age[age > 15])
# 取反~
print(age[~(age > 15)])
# 满足多个条件 &表示与，|表示或
print((age>=0) & (age<=100))

将所有大于100的值设为100

data=np.array([10,101,40,232,231,99,11])
bool_array=data>100
print(data[bool_array])
data[data>100]=100
print(data)

6.数组扁平化

• ravel：视图（共享）
• flatten:拷贝（互不干扰）

a=np.arange(24).reshape(3,8)
print(a.ravel())
print(a.flatten())

7.数组的存储顺序

两者的扁平化方式不同

• C：按照行扁平化，按照C（行）插值
• F：按照列扁平化，按照F（列）插值

a=np.array([[1,2],[3,4]],order='C')
print(a)
b=np.array([[1,2],[3,4]],order='F')
print(b)

c=np.array([[1,2,3],[2,5,6]]).reshape((3,2),order='C')
print(c)
d=np.array([[1,2,3],[2,5,6]]).reshape((3,2),order='F')
print(d)

8函数

8.1通用函数

可以省掉很多循环

• abs

a=np.array([-1.5,-3,-9])
print(np.abs(a))

• cell（向上取整）/floor（向下取整）
• exp
• log/loga/log10
• modf：分别返回小数部分和整数部分

 a=np.array([-1.5,-3,-9])
print(np.modf(a))

• sin/sinh/cos/cosh
• sqrt

8.2统计函数

• mean/sum
• max/min
• argmax/argmin：求最大值和最小值的下标（索引）
• std/var：求标准差和方差
• cumsum/cumprod：求累积和、求累积乘积
• 轴axis：按照不同的标准（轴）来统计：0是竖直方向，1是水平方向（2维）

0	0	0	1	2	3
\	1	\	\	\	\
\	2	\	\	\	\
1	0	0	1	2	3
\	1	\	\	\	\
\	2	\	\	\	\

axis=0:[0][0][0] 和[1][0][0]
axis=1:[0][0][0] 和[0][1][0]
axis=2:[0][0][0] 和[0][0][1]
按照指定统计的轴变化的方向，指定的轴下标改变，其他轴不变

-n~-1	0~n-1
-1和n-1对应	-2和n-2对应

8.3随机函数

• random.rand
• random.randn:标准正态分布的随机数：均值（loc）是0，标准差(scale)是1
• random.normal:可以指定均值和标准差
• random.randint:在一个区间产生随机整数，包括起始点不包括终点，可以指定矩阵大小
• random.seed:种一个种子，使得给定相同的种子能够得到一样的随机数序列
• random.shuffle:对一组序列进行洗牌
• unifrom:在给定范围内产生随机数

print(np.random.rand(5,4))
print(np.random.randn(5,4))
print(np.random.normal(size=(5,4),loc=2,scale=2))
print(np.random.randint(1,10,size=(10,8)))
# seed
random.seed(10)
print(random.random()) 

# shuffle
a=np.arange(10)
print(a)
np.random.shuffle(a)
print(a)

# unifrom
a=np.random.uniform(low=5.1,high=10.5,size=(5,5))
print(a)

8.4连接与拆分函数

1. 合并数组，axis指定方向

x=np.arange(1,10).reshape(3,3)
y=np.arange(10,19).reshape(3,3)
print(x,y)
b=np.concatenate((x,y),axis=0)
print(b)
# axis=0:竖直；axis=1:水平

np.vstack=concatenate(axis=0)/np.hstack=concatenate(axis=1)

2. 拆分：
   可以整除

a=np.arange(36).reshape(6,6)
print(a)
print(np.split(a,3,axis=0))

不可以整除，不等分

print(np.split(a,[1,3],axis=0))

#指定列表拆分的参数为[2,1,3]等等

8.5排序函数

• 尽管很多方法，我们可以通过np.方法名（）与数组对象.方法名（）都能够调用，但是二者不是等价的
• sort就是个特例
• 数组对象.方法名（）在原数据上改变，没有返回结果，所以赋值给数组名.方法名会出现None,而np.方法名没有改变原数据
• sort:numpy和python中都有这个函数，但是不一样

 a=np.array([1,10,-2,-34,232])
print(np.sort(a))
a.sort()
print(a)

• unique： 去掉重复值并且排序

 a=np.array([1,10,-2,-34,22,1,-2,20,-2])
print(np.unique(a))

• where

 x=np.array([1,10,-2,-20,-2]) y=np.array([4,1,6,10,2])
 print(np.where(x>y,x,y))

• np.save:二进制存储

a=np.array([1,10,-2,-34,22,1,-2,20,-2]).reshape(3,3)
# 缀名：npy
np.save('c:/data',a)
print(np.load('c:/data.npy'))
# 缀名：文本
# savetxt只能保存二维
np.savetxt('c:/data1',a,fmt='%d')
print(np.loadtxt('c:/data1'))

图像

1. 图像读取与显示

import matplotlib.pyplot as plt

• plt.imread：读取图像
• plt.imshow：显示图像
• plt.imsave：保存图像

2.纯色图

图像有两种表示方法

• 无符号的np.uint8:0~255
• floatl类型：0.0~1.0

import numpy as np
import matplotlib.pyplot as plt
a=np.ones(shape=(351,500,3))
print(a)
b=a*[110,0,0]
print(b)
plt.imshow(b.astype(np.uint8))
# plt.imshow(b)
# plt.imsave('c:/color.png',b)
plt.imsave('c:/color.png', b.astype(np.uint8))
plt.show()

2. 图像灰度处理

根据固定公式

# 灰度转换
a=plt.imread('c:/1.jpg')
# plt.imshow(a.astype(np.uint8))
# plt.show()
# # 方法一
c=np.dot(a,[0.299,0.587,0.114])
print(c)
print(c.shape)
plt.imshow(c,cmap='gray')
plt.show()
# # 方法二
e=np.max(a,axis=2)

3.多个图显示在一起

plt.subplot(2,2,1)
plt.imshow(c,cmap='gray')
plt.subplot(2,2,2)
plt.imshow(e,cmap='gray')
plt.subplot(2,2,3)
plt.imshow(np.mean(a,axis=2),cmap='gray')
plt.subplot(2,2,4)
plt.imshow(np.min(a,axis=2),cmap='gray')
plt.show()

4.图片颜色通道

若要提取某通道，则让其他两个通道为0

# 图像颜色通道
t=a.copy()
t[:,:,(0,2)]=0
# t[:,:,:2]=0
# t[:,:,1:3]=0
print(t)
plt.imshow(t)
plt.show()

5.图像重复

a=plt.imread('c:/1.jpg')
b=np.concatenate((a,a,a),axis=1)
plt.imshow(b.astype(np.uint8))
plt.show()

a=plt.imread('c:/1.jpg')
b=np.concatenate((a,a,a),axis=0)
c=np.concatenate((b,b,b),axis=1)
plt.imshow(c.astype(np.uint8))
plt.show()

6.镜面对称

a[:]
a[:,:]
a[:,:,:]

a=plt.imread('c:/python.jpg')
print(a)
b=a[::-1,:]
print(b)
plt.imshow(b)
plt.show()
plt.imshow(a)
plt.show()

b = a[i:j:s]，s表示步进，缺省为1.
所以a[i:j:1]相当于a[i:j]
当s<0时，i缺省时，默认为-1. j缺省时，默认为-len(a)-1
所以a[::-1]相当于 a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍，即倒序。

7.旋转

向左90度

a=plt.imread('c:/python.jpg')
t=a.swapaxes(0,1)
t=t[::-1,:]
plt.imshow(t)
plt.show()

向右90度

a=plt.imread('c:/python.jpg')
t=a.swapaxes(0,1)
t=t[:,::-1]
plt.imshow(t)
plt.show()

旋转180度

a=plt.imread('c:/python.jpg')
t=a[::-1]
t=t[:,::-1]
plt.imshow(t)
plt.show()

8.颜色转换

r,g,b——>g,b,r
绿色——>红色
蓝色——>绿色
红色——>蓝色

a=plt.imread('c:/1.jpg')
t=a[:,:,[1,2,0]]
plt.imshow(t)
plt.show()

9.颜色遮挡、叠加

# 用一个单一的颜色遮挡
a=plt.imread('c:/1.jpg')
t=a.copy()
t[50:150,0:100]=[0,255,0]
plt.imshow(t)
plt.show()

生成随机的图遮挡

a=plt.imread('c:/1.jpg')
t=a.copy()
k=np.random.randint(0,256,(100,100,3),dtype=np.uint8)
t[100:200, 100:200] = k
plt.imshow(t)
plt.show()

a=plt.imread('c:/1.jpg')
t=a.copy()
k=t[150:250,100:200]
t[100:200,100:200] = k
plt.imshow(t)
plt.show()

10.图像分块

# 方法一
a=plt.imread('c:/1.jpg')
t=a.copy()
t=np.concatenate((t[10:30],t[50:70]),axis=0)
plt.imshow(t)
plt.show()
# 方法二
a=plt.imread('c:/1.jpg')
t=a.copy()
height=t.shape[0]
weight=t.shape[1]
# 在行上分块再打乱重新组合
li=np.split(t,range(30,height,30),axis=0)
# [:a],[a:b],[b:c]  所以从a点直接开始，不从0开始
np.random.shuffle(li)
aa=np.concatenate(li,axis=0)
# 在列上分块再重新组合
row=np.split(aa,range(30,weight,30),axis=1)
np.random.shuffle(row)
bb=np.concatenate(row,axis=1)
plt.imshow(bb)
plt.show()