>

LoeiJe

:D 获取中...

何以解忧？唯有暴富

numpy学习笔记

numpy学习笔记

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 2019-10-25 不更新时间了
# numpy 学习笔记
# icenaive
# 参考： https://github.com/lijin-THU/notes-python
# 仅供个人学习使用
#
# 11. 生成数组的函数
import numpy as np

# arange 类似与python中的range函数，只不过返回的是数组不是list
# arange(start, stop = None, step = 1, dtype = None)
# 产生一个在区间[start, stop)之间， 以step为间隔的数组，如果
# 只输入一个参数，则默认从0开始，到这个值结束

a = np.arange(4)
print(a)

# 与range不同，arange允许非整数值的输入，产生一个非整形的数组
a = np.arange(0, 2 * np.pi, np.pi / 4)
print(a)

# 数组的类型默认由参数start. stop, step来确定，也可以指定
a = np.arange(0, 2 * np.pi, np.pi / 4, dtype = np.int32)
print(a)

# 由于存在精度问题，使用浮点数可能出现问题
print(np.arange(1.5, 2.1, 0.3))

# stop = 2.1 出现在了数组结果中
# 所以使用浮点数的时候需要注意

# linspace
# linspace(start, stop, N)
# 产生N个等距分布在[start, stop]间的元素组成的数组，包括start, stop
print(np.linspace(0, 1, 5))

# logspace(start, stop, N)
# 产生N个对数等距分布的数组， 默认以10为底
print(np.logspace(0, 1, 5))
# 产生的值是 10^0, 10^0.25, 10^0.5...

# meshgrid可以在二维平面中生成一个网格，
x_ticks = np.linspace(-1, 1, 5)
y_ticks = np.linspace(-1, 1, 5)
x, y = np.meshgrid(x_ticks, y_ticks)
print(x)
print(y)
# x对应于网格第一维
# y为第二维

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm

def f(x, y):
    # sinc 函数
    r = np.sqrt(x ** 2 + y ** 2)
    result = np.sin(r) / r
    result[r == 0] = 1.0
    return result

x_ticks = np.linspace(-10, 10, 51)
y_ticks = np.linspace(-10, 10, 51)
# x, y = np.meshgrid(x_ticks, y_ticks)
x, y = np.ogrid[-10:10:51j, -10:10:51j]

z = f(x, y)
fig = plt.figure()
ax = fig.add_subplot(111, projection = '3d')
ax.plot_surface(x, y, z, rstride = 1, cstride = 1, cmap = cm.YlGnBu_r)

ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')

# 显示图像
# plt.show()

print(x, y)

# 在x y 中还有很多的冗余的元素，这里提供了一个 sparse的选项：
x_ticks = np.linspace(-1, 1, 5)
y_ticks = np.linspace(-1, 1, 5)

x, y = np.meshgrid(x_ticks, y_ticks, sparse=True)
print(x, y)

# 在这个选项下，x, y 变成了单一的行向量和列向量。
# 但这并不影响结果：

# meshgrid 可以设置轴排列的先后顺序：
# 默认为 indexing = 'xy' 即笛卡尔坐标，对于2维数组，返回行向量 x 和列向量 y
# 或者使用 indexing = 'ij' 即矩阵坐标，对于2维数组，返回列向量 x 和行向量 y。

# ogrid mgrid
# matlab 中 有meshgrid的用法
#   meshgrid(-1:.5:1, -1:.5:1)
# numpy 的meshgrid并不支持这样的用法，但我们可以使用 ogrid / mgrid 来实现类似这样的用法。
# ogrid 与 mgrid 的区别在于：
# ogrid 相当于 meshgrid(indexing='ij', sparse=True)
# mgrid 相当于 meshgrid(indexing='ij', sparse=False)

x, y = np.ogrid[-1:1:.5, -1:1:.5]
print(x, '\n', y)

x, y = np.mgrid[-1:1:.5, -1:1:.5]
print(x, "\n", y)

# 注意：
# 这里使用的是中括号
# Matlab 使用的是 start: step: end 的表示，Numpy 使用的是 start: end: step 的表示
# 这里的结果不包括 end 的值
# 为了包含 end 的值，我们可以使用这样的技巧：

x, y = np.ogrid[-1:1:5j, -1:1:5j]
print(x, "\n", y)

# 我们在 step 的位置传入一个复数 5j ，表示我们需要一个 5 个值的数组，此时返回值就会包含 end 的值

# r_, c_
# 可以用来产生行向量或者列向量
# 使用切片产生
print(np.r_[0 : 1 : .1])
# 复数步长指定数组长度, j前的数为数组长度
print(np.r_[0 : 1 : 10j])

# 连接多个序列，产生数组
print(np.r_[(3, 22, 11), 4.0, [15, 6]])

# 列向量
print(np.c_[1:3:5j])

# ones, zeros
# ones(shape, dtype = np.float64)
# zeros(shape, dtype = np.float64)
# 产生一个指定形状的全0或者全1的数组，还可以指定数组类型
print(np.zeros(3))
print(np.ones([2, 3], dtype = np.float32))
# 产生一个全是5的数组
print(np.ones([2, 3]) * 5)

# empty
# empty(shape, dtype = np.float64, order = 'c')
# 也可以使用 empty方法产生一个制定大小的数组（数
# 组所指向的内存未被初始化，所以值随机），再用 fill
# 方法填充：
a = np.empty(2)
print(a)
a.fill(6)
print(a)
# 另一种替代方法使用索引 速度会变慢一些
a[:] = 5
print(a)

# empty_like ones_like zeros_like
# empty_like(a)
# ones_like(a)
# zeros_like(a)
# 产生一个跟 a 大小一样，类型一样的对应数组。

a = np.arange(0, 10, 2.5)
print(a)
# a = np.array([1, 2, 3, 4])
# print(a)
a = np.arange(0, 10, 3)
# 返回一个跟a形状相同的空数组
print(np.empty_like(a))
print(np.zeros_like(a))
print(np.ones_like(a))

# identity(n, dtype = np.float64)
# 产生一个n * n 的单位矩阵
print(np.identity(6))
学习笔记