当前位置：首页 > news >正文

数据分析DAY1

news 2026/2/9 12:11:10

数据分析

引言

这一周：学习了python的numpy和matplotlib以及在飞桨paddle上面做了几个小项目

发现numpy和matplotlib里面有很多api，要全部记住是不可能的，也是不可能全部学完的，所以我们要知道并且熟悉一些常用的api，并且学到哪用到哪，遇到不会的api也不要害怕，直接去网上查找或者自己尝试着摸索就可以了的，代码也不需要特别死扣，思路是最重要的。

什么是数据分析？

数据分析是指用适当的统计分析方法对收集来的大量数据进行分析，提取有用信息和形成结论而对数据加以详细研究和概括总结的过程。

使用python做数据分析的常用库

numpy 基础数值算法
matplotlib 数据可视化
pandas 序列高级函数

numpy的核心：多维数组

代码简洁：减少Python代码中的循环。
底层实现：厚内核©+薄接口(Python)，保证性能。

numpy基础

ndarray数组

用np.ndarray类的对象表示n维数组

import numpy as np
ary = np.array([1, 2, 3, 4, 5, 6])
print(type(ary))#<class 'numpy.ndarray'>

内存中的ndarray对象

元数据（metadata）

存储对目标数组的描述信息，如：dim count、dimensions、dtype、data等。

实际数据

完整的数组数据[1,2,3,4,5,6]

将实际数据与元数据分开存放，一方面提高了内存空间的使用效率，另一方面减少对实际数据的访问频率，提高性能。

ndarray数组对象的特点

Numpy数组是同质数组，即所有元素的数据类型必须相同
Numpy数组的下标从0开始，最后一个元素的下标为数组长度减1

ndarray数组对象的创建

np.array(任何可被解释为Numpy数组的逻辑结构)

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

np.arange(起始值(0),终止值,步长(1))

import numpy as np
a = np.arange(0, 5, 1)
print(a)
b = np.arange(0, 10, 2)
print(b)#默认生成每一个元素的维度都是一维的，而且它每一个元素的是默认的int32

np.zeros(数组元素个数, dtype=‘类型’)

import numpy as np
a = np.zeros(10)
print(a)#默认生成每一个元素的是float64，默认0.

np.ones(数组元素个数, dtype=‘类型’)

import numpy as np
a = np.ones(10)
print(a)#默认生成的每一个元素都是float64，都是1.

# 构建一个结构与a1相同的全0数组
print(np.zeros_like(a1))
# 构建一个结构与a3相同的全1数组
print(np.ones_like(a3))#维度是一样的

ndarray对象属性的基本操作

**数组的维度：**np.ndarray.shape

import numpy as np
ary = np.array([1, 2, 3, 4, 5, 6])
print(type(ary), ary, ary.shape)
#二维数组
ary = np.array([[1,2,3,4],[5,6,7,8]
])
print(type(ary), ary, ary.shape)

**元素的类型：**np.ndarray.dtype

import numpy as np
ary = np.array([1, 2, 3, 4, 5, 6])
print(type(ary), ary, ary.dtype)
#转换ary元素的类型
b = ary.astype(float)
print(type(b), b, b.dtype)
#转换ary元素的类型
c = ary.astype(str)
print(type(c), c, c.dtype)

**数组元素的个数：**np.ndarray.size

import numpy as np
ary = np.array([[1,2,3,4],[5,6,7,8]
])
#观察维度，size，len的区别
print(ary.shape, ary.size, len(ary))
#shape指的是数组的维度，size指的是数组的元素个数，len指的是数组的行数

数组元素索引(下标)

数组对象[…, 页号, 行号, 列号]

下标从0开始，到数组len-1结束。

import numpy as np
a = np.array([[[1, 2],[3, 4]],[[5, 6],[7, 8]]])
print(a, a.shape)#(3,2,2)
print(a[0])#第一页
print(a[0][0])#第一页第一行
print(a[0][0][0])#第一页第一行第一列
print(a[0, 0, 0])#第二种写法
#当是三维数组的时候，循环遍历每一个元素
for i in range(a.shape[0]):#页数for j in range(a.shape[1]):#行数for k in range(a.shape[2]):#列数print(a[i, j, k])#访问每一个元素

ndarray对象属性操作详解

Numpy的内部基本数据类型

类型名	类型表示符
布尔型	bool_
有符号整数型	int8(-128~127)/int16/int32/int64
无符号整数型	uint8(0~255)/uint16/uint32/uint64
浮点型	float16/float32/float64
复数型	complex64/complex128
字串型	str_，每个字符用32位Unicode编码表示

自定义复合类型

#如果不用这种方法，那么你也可以先创建一个类，里面有对象的各种属性，然后再创建一个对象列表，但是这样虽然思路上十分清晰，但是很耗时间，占内存，所以不建议使用这种方法，numpy里面虽然大部分只能用在数字上，但是也为此有了一种自定义复合类型。如果要访问属性的时候，只需要访问他的字段

# 自定义复合类型
import numpy as npdata=[('zs', [90, 80, 85], 15),('ls', [92, 81, 83], 16),('ww', [95, 85, 95], 15)
]
#第一种设置dtype的方式
a = np.array(data, dtype='U3, 3int32, int32')
print(a)
print(a[0][0],:,a[0][1])
print(a[0]['f0'], ":", a[1]['f1'])
print("=====================================")
#第二种设置dtype的方式
b = np.array(data, dtype=[('name', 'str_', 2),('scores', 'int32', 3),('ages', 'int32', 1)])
print(b[0]['name'], ":", b[0]['scores'])
print("=====================================")#第三种设置dtype的方式
#最常用
c = np.array(data, dtype={'names': ['name', 'scores', 'ages'],'formats': ['U3', '3int32', 'int32']})
print(c[0]['name'], ":", c[0]['scores'], ":", c.itemsize)
print("=====================================")#第四种设置dtype的方式  
d = np.array(data, dtype={'name': ('U3', 0),#数字代表的是偏移位置，单位是字节'scores': ('3i4', 16),'age': ('i4', 28)})
print(d[0]['name'], d[0]['scores'], d.itemsize)print("=====================================")
#测试日期类型数组
f = np.array(['2011', '2012-01-01', '2013-01-01 01:01:01','2011-02-01'])
f = f.astype('M8[D]')#把类型转化为只精确到天数的
f = f.astype('int32')
print(f[3]-f[0])#一个月31print("=====================================")
#复数
a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],[4 + 2j, 5 + 5j, 6 + 8j],[7 + 3j, 8 + 6j, 9 + 9j]])
print(a.T)#进行转置for x in a.flat:#flat返回一个可迭代的一维数组print(x.array(a.flat))#[1.+1.j 2.+4.j 3.+7.j 4.+2.j 5.+5.j 6.+8.j 7.+3.j 8.+6.j 9.+9.j]print(x.imag)#得到每一个元素的虚部

类型字符码

类型	字符码
np.bool_	?
np.int8/16/32/64	i1/i2/i4/i8
np.uint8/16/32/64	u1/u2/u4/u8
np.float/16/32/64	f2/f4/f8
np.complex64/128	c8/c16
np.str_	U<字符数>
np.datetime64	M8[Y] M8[M] M8[D] M8[h] M8[m] M8[s]`

类型字符码格式

<字节序前缀><维度><类型><字节数或字符数>

	释义
3i4	大端字节序，3个元素的一维数组，每个元素都是整型，每个整型元素占4个字节。
<(2,3)u8	小端字节序，6个元素2行3列的二维数组，每个元素都是无符号整型，每个无符号整型元素占8个字节。
U7	包含7个字符的Unicode字符串，每个字符占4个字节，采用默认字节序。

ndarray数组对象的维度操作

视图变维（数据共享）： reshape() 与 ravel()

import numpy as np
a = np.arange(1, 9)
print(a)		# [1 2 3 4 5 6 7 8]
b = a.reshape(2, 4)#一定要拿一个变量来接收	#视图变维  : 变为2行4列的二维数组
print(b)
a[0]=10000
print(b)
#[[10000     2     3     4]
# [    5     6     7     8]]
c = b.reshape(2, 2, 2) #视图变维    变为2页2行2列的三维数组
print(c)
d = c.ravel()	#视图变维	变为1维数组
print(d)

**复制变维（数据独立）：**flatten()

e = c.flatten()
print(e)
c += 10
print(c, e, sep='\n')

就地变维：直接改变原数组对象的维度，不返回新数组

a.shape = (2, 4)
print(a)
a.resize(2, 2, 2)
print(a)

ndarray数组切片操作

#数组对象切片的参数设置与列表切片参数类似
#  步长+：默认切从首到尾
#  步长-：默认切从尾到首
数组对象[起始位置:终止位置:步长, ...]
#默认位置步长：1

import numpy as np
a = np.arange(1, 10)
print(a)  # 1 2 3 4 5 6 7 8 9
print(a[:3])  # 1 2 3
print(a[3:6])   # 4 5 6
print(a[6:])  # 7 8 9
print(a[::-1])  # 9 8 7 6 5 4 3 2 1
print(a[:-4:-1])  # 9 8 7
print(a[-4:-7:-1])  # 6 5 4
print(a[-7::-1])  # 3 2 1
print(a[::])  # 1 2 3 4 5 6 7 8 9
print(a[:])  # 1 2 3 4 5 6 7 8 9
print(a[::3])  # 1 4 7
print(a[1::3])  # 2 5 8
print(a[2::3])  # 3 6 9

多维数组的切片操作

import numpy as np
a = np.arange(1, 28)
a.resize(3,3,3)
print(a)
#切出1页 
print(a[1, :, :])		
#切出所有页的第二行
print(a[:, 1, :])		
#切出0页的第二列
print(a[0, :, 1])

ndarray数组的掩码操作

import numpy as np
a = np.arange(0, 10)
mask = [True, False,True, False,True, False,True, False,True, False]
print(a[mask])#得到True组成的数组
# bool掩码
a = np.arange(10)
mask = a % 2 == 0
print(a[mask])
print(a[a%2==0])
# 3与7的公倍数
a = np.arange(1, 100)
print(a[(a%3==0) & (a%7==0)])# 索引掩码
a = np.array([10, 20, 30, 40])
mask = [0,3,2,0,1,2,0,3,1,2,3,0,2]
print(a[mask])
#[10 40 30 10 20 30 10 40 20 30 40 10 30]

多维数组的组合与拆分

垂直方向操作：

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 垂直方向完成组合操作，生成新数组
c = np.vstack((a, b))#上下组合
# 垂直方向完成拆分操作，生成两个数组
d, e = np.vsplit(c, 2)#水平拆分，第一个参数是待拆分的元素，第二个元素是待拆分的数组总数

水平方向操作：

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 水平方向完成组合操作，生成新数组 
c = np.hstack((a, b))
# 水平方向完成拆分操作，生成两个数组
d, e = np.hsplit(c, 2)

深度方向操作：（3维）

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 深度方向（3维）完成组合操作，生成新数组
i = np.dstack((a, b))
# 深度方向（3维）完成拆分操作，生成两个数组
k, l = np.dsplit(i, 2)

多维数组组合与拆分的相关函数：

# 通过axis作为关键字参数指定组合的方向，取值如下：
# 若待组合的数组都是二维数组：
#	0: 垂直方向组合
#	1: 水平方向组合
# 若待组合的数组都是三维数组：
#	0: 垂直方向组合
#	1: 水平方向组合
#	2: 深度方向组合
np.concatenate((a, b), axis=0)
# 通过给出的数组与要拆分的份数，按照某个方向进行拆分，axis的取值同上
np.split(c, 2, axis=0)

长度不等的数组组合：

import numpy as np
a = np.array([1,2,3,4,5])
b = np.array([1,2,3,4])
# 填充b数组使其长度与a相同,头部添加0个元素，尾部添加1个元素
b = np.pad(b, pad_width=(0, 1), mode='constant', constant_values=-1)#默认mode='constant',constant_values=0
print(b)
# 垂直方向完成组合操作，生成新数组
c = np.vstack((a, b))
print(c)

简单的一维数组组合方案

a = np.arange(1,9)		#[1, 2, 3, 4, 5, 6, 7, 8]
b = np.arange(9,17)		#[9,10,11,12,13,14,15,16]
#把两个数组摞在一起成两行
c = np.row_stack((a, b))
print(c)
#把两个数组组合在一起成两列
d = np.column_stack((a, b))
print(d)

ndarray类的其他属性

shape - 维度
dtype - 元素类型
size - 元素数量
ndim - 维数，len(shape)
itemsize - 元素字节数
nbytes - 总字节数 = size x itemsize
real - 复数数组的实部数组
imag - 复数数组的虚部数组
T - 数组对象的转置视图
flat - 扁平迭代器,#生成可迭代的一维数组对象

import numpy as np
a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],[4 + 2j, 5 + 5j, 6 + 8j],[7 + 3j, 8 + 6j, 9 + 9j]])
print(a.shape)
print(a.dtype)
print(a.ndim)
print(a.size)
print(a.itemsize)
print(a.nbytes)
print(a.real, a.imag, sep='\n')
print(a.T)
print([elem for elem in a.flat])
b = a.tolist()#把数组转换成列表
print(b)