数据分析（numpy基础）

最新推荐文章于 2024-08-14 17:28:43 发布

置顶 zsj.python之路

最新推荐文章于 2024-08-14 17:28:43 发布

阅读量559

点赞数 2

分类专栏：数据分析文章标签： numpy 数据分析

本文链接：https://blog.csdn.net/zhangshuaijun123/article/details/84943538

版权

数据分析专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Numpy + Scipy + Pandas + Matplotlib
数值计算科学应用数据清洗数据可视化
一、Numpy概述

1.Numpy是什么？

1)基于C语言和Python接口的数值算法库；
2)开源免费；
3)弥补了Python语言在数值计算方面的短板；
4)作为常用科学计算工具的底层支撑；

2.Numpy的历史

1)1995年，Numeric作为Python语言数值计算扩展；
2)2001年，Scipy项目，Numarray矢量化操作；
3)2005年，Numeric+Numarray->Numpy；
4)2006年，Numpy脱离Scipy项目，独立发布；

3.Numpy的性能

1)简化代码编写，提高开发效率；
2)通过优化底层实现，提高运行速度；

代码：

# -*- coding: utf-8 -*-
import datetime as dt
import numpy as np

n = 100000
# 不使用numpy
start = dt.datetime.now()  # 开始时间
A, B = [], []
for i in range(n):
    A.append(i ** 2)
    B.append(i ** 3)
C = []
for a, b in zip(A, B):
    C.append(a + b)
print((dt.datetime.now() - start).microseconds)  # 所用时间：104529

# 使用numpy
start = dt.datetime.now()
A, B = np.arange(n) ** 2, np.arange(n) ** 3
C = A + B
print((dt.datetime.now() - start).microseconds)  # 所用时间：13239

二、Numpy基础
1.数组

1)Numpy中的数组是ndarray类实例化的对象，其中包括：
  实际数据：数组的内容
  元数据：对数组的描述
  大部分对数组的操作仅仅是对元数据的操作，以此提高执行性能
2)Numpy中的数组必须是同质的，即所有元素的数据类型必须完全相同
3)通过基0的下标访问数组中的元素
  10: [0, 9]
4)dtype和shape属性分别表示元素类型和维度
5)实例化
  np.arange(起始值,终止值,步长)->[起始值,终止值)
  默认起始值：0
  默认步长：1
  np.array(任何可被解释为数组的序列)->数组
6)类型转换
  数组.astype(目标类型)->转换后的新数组

代码：

	# -*- coding: utf-8 -*-
	from __future__ import unicode_literals
	import numpy as np
	a = [[1, 2, 3],
	     [4, 5, 6]]
	print(type(a))  # <class 'list'>
	print(a)  # [[1, 2, 3], [4, 5, 6]]
	
	b = np.array(a)
	print(type(b))  # <class 'numpy.ndarray'>
	print(b)    # [[1 2 3]
	             # [4 5 6]]
	
	print(b.dtype, type(b[0][0]))  # int64 <class 'numpy.int64'>
	print(b.shape)  # (2, 3)
	
	c = np.arange(1, 10, 2)
	print(c, c.shape, c.dtype)  # [1 3 5 7 9] (5,) int64
	
	d = np.array([np.arange(1, 4), np.arange(4, 7)])
	print(d, d.shape, d.dtype, sep='\n')
	''' 
	    [[ 1.  2.  3.]
	     [ 4.  5.  6.]]
	    (2, 3)  
	    int64
	''' 
	
	# 转化为float
	e = d.astype(float)
	print(e, e.shape, e.dtype, sep='\n')
	'''
	    [[ 1.  2.  3.]
	     [ 4.  5.  6.]]
	    (2, 3)
	    float64
	'''
	# 转化为str
	f = e.astype(str)
	print(f, f.shape, f.dtype, sep='\n')
	'''
	    [['1.0' '2.0' '3.0']
	     ['4.0' '5.0' '6.0']]
	    (2, 3)
	    <U32
	'''
	# <U32表示字符串，其中每个字符都
	# 是小端字节序的32位Unicode字符

2.多维数组和元素索引

1)数组的维度表示为一个元组：其中的元素按照从高维度数到低维度数的顺序排列。
  一维数组，6个元素：(6,)
  二维数组，2行3列：(2, 3)
  三维数组，2页3行4列：(2, 3, 4)

2)通过下标运算符访问数组中的元素

数组[页标][行标][列标]
数组[页标,行标,列标]

代码：

	# -*- coding: utf-8 -*-
	from __future__ import unicode_literals
	import numpy as np
	a = np.array([
	    [[1, 2, 3, 4],
	     [5, 6, 7, 8],
	     [9, 10, 11, 12]],
	    [[13, 14, 15, 16],
	     [17, 18, 19, 20],
	     [21, 22, 23, 24]]])
	print(a)
	print(a.shape)
	print(a[1][1][1])
	'''
	[[[ 1  2  3  4]
	  [ 5  6  7  8]
	  [ 9 10 11 12]]
	
	 [[13 14 15 16]
	  [17 18 19 20]
	  [21 22 23 24]]]
	(2, 3, 4)
	18
	'''
	
	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])
	        # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

3.数据类型

存储形式，处理方式
1)内置类型
  布尔型
  bool_：True/False
  整型
  有符号：int8/int16/int32/int64
  无符号：uint8/uint16/uint32/uint64
  浮点型
    float16/float32/float64
  复数型
    complex64/complex128
  字符串
    str_
2)复合类型
  有多个相同或不同类型的字段组合而成的类型
  np.array(..., dtype=复合类型）

3)类型字符码

bool_: ?
有符号整型：i1/2/4/8
无符号整型：u1/2/4/8
浮点型：f2/4/8
复数型：c8/16
字符串：U&lt;字符数&gt;
日期时间：M
字节序(针对多字节整型)：&lt;/&gt;/[=]表示小端/大端/硬件

4.切片

数组[起始:终止:步长, 起始:终止:步长, ...]
默认起始：首(正步长)/尾(负步长)
默认终止：尾后(正步长)/首前(负步长)
默认步长：1

代码：

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
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[::-1])  # 9 8 7 6 5 4 3 2 1
print(a[:-4:-1])  # 9 8 7

#　步长变换
print(a[::3])  # 1 4 7
print(a[1::3])  # 2 5 8
print(a[2::3])  # 3 6 9

b = np.arange(1, 25).reshape(2, 3, 4)
print(b)
'''
    [[[ 1  2  3  4]
      [ 5  6  7  8]
      [ 9 10 11 12]]

     [[13 14 15 16]
      [17 18 19 20]
      [21 22 23 24]]]
'''

print(b[:, 0, 0])  # [1 13] 取第一页和第二页的第一行，第一列
print(b[0])
'''
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]]
'''
'''
  print(b[0, :, :])
  print(b[0, ...])
  注释的两个print与print(b[0])的结果相同
'''
# 指定位置切片
print(b[0, 1])  # 5 6 7 8
print(b[0, 1, ::2])  # 5 7
print(b[..., 1])
'''
    [[ 2  6 10]
     [14 18 22]]
    ... 指将前面的页，行省略，默认值为0,
    1指的是第下标索引在1位置的列
'''
print(b[:, 1])
'''
    [[ 5  6  7  8]
     [17 18 19 20]]
    将第一页和第二页的第二行的数据切出来

'''
print(b[0, 1, 1::2])  # 6 8
print(b[0, :, -1])  # 4 8 12
print(b[0, ::-1])
'''
    [[ 9 10 11 12]
     [ 5  6  7  8]
     [ 1  2  3  4]]
'''
print(b[0, ::-1, -1])  # 12 8 4
print(b[0, ::2, -1])  # 4 12
print(b[::-1, ::-1])
'''
    [[21 22 23 24]
      [17 18 19 20]
      [13 14 15 16]]

     [[ 9 10 11 12]
      [ 5  6  7  8]
      [ 1  2  3  4]]]
'''
print(b[..., ::-1])
'''
	    [[[ 4  3  2  1]
	      [ 8  7  6  5]
	      [12 11 10  9]]

     [[16 15 14 13]
      [20 19 18 17]
      [24 23 22 21]]]
      print(b[-1, 1:, 2:])
 	  # 19 20
 	  # 23 24
'''

5.变维

1)视图变维：元数据独立，实际数据共享
	数组.reshape(新维度)->新数组
  	 \_____________________/
                |
            元数据独立
           实际数据共享
		元素数和维度数必须匹配
  (8,) -> (2,4) -> (4,2) ->(2,2,2) -X-> (3,3)
  数组.ravel()->一维数组
2)复制变维：元数据和实际数据都是独立的
  数组.flatten()->一维数组
	\_________________/
             |
         元数据独立
        实际数据独立
3)就地变维：修改元数据的维度信息，不产生新的数组
  数组.shape = 新维度
  数组.resize(新维度)

代码：

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.arange(1, 9)
print(a)
 [1 2 3 4 5 6 7 8]
b = a.reshape(2, 4)
print(b)
'''
[[1 2 3 4]
 [5 6 7 8]]
'''
c = b.reshape(2, 2, 2)
print(c)
'''
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]
'''
d = c.ravel()
print(d)
#[1 2 3 4 5 6 7 8]
e = c.flatten()
print(e)
 [1 2 3 4 5 6 7 8]
a += 10
print(a, b, c, d, e, sep='\n')

'''
    a: [11 12 13 14 15 16 17 18]
    b: [[11 12 13 14]
        [15 16 17 18]]
    c: [[[11 12]
         [13 14]]

       [[15 16]
        [17 18]]]
    d: [11 12 13 14 15 16 17 18]
    e: [1 2 3 4 5 6 7 8]  复制变维：元数据和实际数据都是独立的

'''
a.shape = (2, 2, 2)
print(a)
 就地变维：修改元数据的维度信息，不产生新的数组
'''
 [[[11 12]
  [13 14]]

 [[15 16]
  [17 18]]]
'''
a.resize(4, 2)
print(a)
'''
[[11 12]
 [13 14]
 [15 16]
 [17 18]]
'''

6.组合拆分

1)垂直组合：沿着垂直方向组合两个小的同维数组为一个大数组
  np.vstack((上, 下))
  np.concatenate((上, 下), axis=0)
  axis - 轴向，用维度的下标表示
             0  1
  shape->(2, 4)
2)水平组合：沿着水平方向组合两个小的同维数组为一个大数组
  np.hstack((左, 右))
  np.concatenate((左, 右), axis=1)
3)深度组合：沿着纵深方向组合两个小的同维数组为一个大数组
  np.dstack((前, 后))
4)行组合：以两个一维数组按照行的方式组合成一个二维数组
  np.row_stack((上, 下))
5)列组合：以两个一维数组按照列的方式组合成一个二维数组
  np.column_stack((左, 右))
6)垂直拆分：将一个大的数组沿着垂直方向拆分成若个小的同维数组
  np.vsplit(被拆分数组, 拆分份数)
  np.split(被拆分数组, 拆分份数, axis=0)
7)水平拆分：将一个大的数组沿着水平方向拆分成若个小的同维数组
  np.hsplit(被拆分数组, 拆分份数)
  np.split(被拆分数组, 拆分份数, axis=1)
8)深度拆分：将一个大的数组沿着纵深方向拆分成若个小的同维数组
  np.dsplit(被拆分数组, 拆分份数)

代码：

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.arange(11, 20).reshape(3, 3)
print(a)
b = a + 10
print(b)
#c = np.vstack((a, b))
c = np.concatenate((a, b), axis=0)
print(c)
#d = np.hstack((a, b))
d = np.concatenate((a, b), axis=1)
print(d)
e = np.dstack((a, b))
print(e)
f, g = a[0], b[0]
print(f, g)
h = np.row_stack((f, g))
print(h)
i = np.column_stack((f, g))
print(i)
#j, k, l = np.vsplit(c, 3)
j, k, l = np.split(c, 3, axis=0)
print(j, k, l, sep='\n')
#m, n, o = np.hsplit(d, 3)
m, n, o = np.split(d, 3, axis=1)
print(m, n, o, sep='\n')
p, q = np.dsplit(e, 2)
print(p, q, sep='\n')
print(p.T[0].T, q.T[0].T, sep='\n')

7.ndarray的属性

dtype - 元素的数据类型
shape - 数组的维度
ndim - 数组的维数，len(shape)
size - 数组的元素数，shape中元素相乘
itemsize - 元素字节数，与dtype相关
nbytes - 总字节数，size x itemsize
T - 转置视图
real - 复数数组的实部视图
imag - 复数数组的虚部视图
flat - 扁平迭代器

8.ndarray<=>list

np.array(列表)->数组
数组.tolist()->列表

代码：

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
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.dtype, a.dtype.str)
print(a.shape)
print(a.ndim, len(a.shape))
print(a.size, len(a))
print(a.itemsize)
print(a.nbytes, a.size * a.itemsize)
print(a.T)
print(a.real)
print(a.imag)
for row in a:
    for col in row:
        print(col)
for v in a.flat:
    print(v)
b = [10, 20, 30, 40, 50]
print(b, type(b))
c = np.array(b)  # list->ndarray
print(c, type(c))
d = c.tolist()  # ndarray->list
print(d, type(d))
e = c  # 浅拷贝
print(e, type(e))
print(id(e), id(c))
e += 1
print(e, c)
f = c.copy()  # 深拷贝
print(f, type(f))
print(id(f), id(c))
f += 1
print(f, c)