Skr-Eric的数据分析课堂（一）--Numpy的介绍和Numpy基础讲解

最新推荐文章于 2023-12-04 22:22:33 发布

Skr-Eric

最新推荐文章于 2023-12-04 22:22:33 发布

阅读量297

点赞数

分类专栏：数据分析--Skr-Eric的编程课堂文章标签： python Numpy

本文链接：https://blog.csdn.net/Skr_Eric/article/details/103927839

版权

数据分析--Skr-Eric的编程课堂专栏收录该内容

7 篇文章 1 订阅

订阅专栏

数据分析

Matlab

Python

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 -*-
from __future__ import unicode_literals
import datetime as dt
import numpy as np
n = 100000
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)
start = dt.datetime.now()
A, B = np.arange(n) ** 2, np.arange(n) ** 3
C = A + B
print((dt.datetime.now() - start).microseconds)

二、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))
print(a)
b = np.array(a)
print(type(b))
print(b)
print(b.dtype, type(b[0][0]))
print(b.shape)
c = np.arange(1, 10, 2)
print(c, c.shape, c.dtype)
d = np.array([np.arange(1, 4), np.arange(4, 7)])
print(d, d.shape, d.dtype, sep='\n')
e = d.astype(float)
print(e, e.shape, e.dtype, sep='\n')
f = e.astype(str)
print(f, f.shape, f.dtype, sep='\n')
# <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])
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])

3.数据类型

存储形式，处理方式

1)内置类型

布尔型

bool_：True/False

整型

有符号：int8/int16/int32/int64

无符号：uint8/uint16/uint32/uint64

浮点型

float16/float32/float64

复数型

complex64/complex128

字符串

str_

2)复合类型

有多个相同或不同类型的字段组合而成的类型

np.array(..., dtype=复合类型)

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.array([('ABC', [1, 2, 3]
               )],
             dtype='U3, 3i4')
print(a[0]['f0'],
      a[0]['f1'][0], a[0]['f1'][1], a[0]['f1'][2])
b = np.array([('ABC', [1, 2, 3])],
             dtype=[('fa', np.str_, 3),
                    ('fb', np.int32, 3)])
print(b[0]['fa'],
      b[0]['fb'][0], b[0]['fb'][1], b[0]['fb'][2])
c = np.array([('ABC', [1, 2, 3])],
             dtype={'names': ['fa', 'fb'],
                    'formats': ['U3', '3i4']})
print(c[0]['fa'],
      c[0]['fb'][0], c[0]['fb'][1], c[0]['fb'][2])
d = np.array([('ABC', [1, 2, 3])],
             dtype={'fa': ('U3', 0),
                    'fb': ('3i4', 16)})
print(d[0]['fa'],
      d[0]['fb'][0], d[0]['fb'][1], d[0]['fb'][2])
# 数组元素的字节数
print(c.itemsize, d.itemsize)
e = np.array([0x1234],
             dtype=('>u2', {'lo': ('u1', 0),
                            'hi': ('u1', 1)}))
print('{:x} {:x} {:x}'.format(
    e[0], e['lo'][0], e['hi'][0]))

3)类型字符码

bool_: ?

有符号整型：i1/2/4/8

无符号整型：u1/2/4/8

浮点型：f2/4/8

复数型：c8/16

字符串：U<字符数>

日期时间：M

字节序(针对多字节整型)：</>/[=]表示小端/大端/硬件

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[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[])  # 错误
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)
print(b[:, 0, 0])  # 1 13
print(b[0])
print(b[0, :, :])
print(b[0, ...])
print(b[0, 1])  # 5 6 7 8
print(b[0, 1, ::2])  # 5 7
print(b[..., 1])
print(b[:, 1])
print(b[0, 1, 1::2])  # 6 8
print(b[0, :, -1])  # 4 8 12
print(b[0, ::-1, -1])  # 12 8 4
print(b[0, ::2, -1])  # 4 12
print(b[::-1, ::-1])
print(b[..., ::-1])
print(b[-1, 1:, 2:])

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)
b = a.reshape(2, 4)
print(b)
c = b.reshape(2, 2, 2)
print(c)
d = c.ravel()
print(d)
e = c.flatten()
print(e)
a += 10
print(a, b, c, d, e, sep='\n')
a.shape = (2, 2, 2)
print(a)
a.resize(4, 2)
print(a)

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((左, 右))

np.c_[左, 右]

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 - 转置视图

1 2 3

4 5 6

变维

1 2

3 4

5 6

转置

1 4

2 5

3 6

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)

想要看更多的课程请微信关注SkrEric的编程课堂