WEBVTT

1
00:00:00.840 --> 00:00:03.620
大家好，欢迎收看另一期艺术家脚本编写节目。

2
00:00:03.710 --> 00:00:06.260
我的名字Sybren，在这一集中我们将

3
00:00:06.260 --> 00:00:09.690
著眼于程式码的可读性和理解能力。

4
00:00:09.910 --> 00:00:12.560
有时让电脑准确地执行任务可能会很棘手

5
00:00:12.560 --> 00:00:16.170
你想要什么，当事情最终成功时，这是一个伟大的胜利，

6
00:00:16.260 --> 00:00:20.460
由于程式码运作正常，因此很容易继续处理手边的下一个任务

7
00:00:22.440 --> 00:00:25.210
好吧，这通常是停止编码的好时机

8
00:00:25.380 --> 00:00:27.320
并再次通读一遍。

9
00:00:27.700 --> 00:00:28.600
问问你自己，

10
00:00:28.730 --> 00:00:31.470
我真的理解程式码为何有效吗？

11
00:00:31.780 --> 00:00:33.360
我明白我写的东西吗？

12
00:00:33.740 --> 00:00:37.710
因为通常当我编写程式码时，看起来完全没问题，但是当我采取

13
00:00:37.710 --> 00:00:40.920
退后一步，试著解释我对我的橡皮鸭做了什么，

14
00:00:40.960 --> 00:00:43.760
我开始注意到一些丑陋或不清楚的地方

15
00:00:44.430 --> 00:00:45.250
在这个影片中，

16
00:00:45.250 --> 00:00:49.420
我们将查看一些搅拌机代码并采取一些步骤来提高其可读性。

17
00:00:49.840 --> 00:00:52.370
最重要的是这些步骤并不

18
00:00:52.380 --> 00:00:55.650
需要了解程式码实际在做什么。

19
00:00:55.690 --> 00:00:58.860
只需要非常肤浅的Python知识。

20
00:00:59.340 --> 00:01:01.480
这意味著您可以使用以下步骤

21
00:01:01.480 --> 00:01:03.650
提高程式码的理解能力

22
00:01:03.760 --> 00:01:05.060
即使是为了你自己。

23
00:01:05.540 --> 00:01:06.050
是的，

24
00:01:06.050 --> 00:01:08.690
重组程式码实际上是获得

25
00:01:08.690 --> 00:01:11.840
更好地理解程式码甚至发现错误，

26
00:01:12.540 --> 00:01:16.810
我想看的外套，在这里画这个面板或相机，

27
00:01:16.810 --> 00:01:17.850
背景影像，

28
00:01:18.240 --> 00:01:21.670
您可以单击每个图像的图像，您将获得一个框。

29
00:01:21.680 --> 00:01:25.580
每个框都允许您选择背景图像的来源，

30
00:01:25.590 --> 00:01:28.710
无论是影像还是影片剪辑，然后

31
00:01:28.720 --> 00:01:31.400
您可以选择影像或影片剪辑，

32
00:01:31.400 --> 00:01:32.490
取决于你的选择。

33
00:01:32.490 --> 00:01:35.020
如果选择了影像或影片剪辑，

34
00:01:35.030 --> 00:01:37.460
你会得到各种不同的选择。

35
00:01:38.520 --> 00:01:40.780
让我们来看看绘制这一切的程式码。

36
00:01:42.240 --> 00:01:43.270
我们在程式码中，

37
00:01:43.270 --> 00:01:47.270
我已经折叠了所有其他目前不感兴趣的类别。

38
00:01:47.410 --> 00:01:51.000
我们只看相机、背景影像类

39
00:01:51.120 --> 00:01:52.490
此类别有两个功能，

40
00:01:52.490 --> 00:01:56.760
绘制标题和绘制并绘制标题非常简单，所以我们将跳过它。

41
00:01:56.770 --> 00:01:59.760
没关系。但抽奖是另一回事。

42
00:01:59.940 --> 00:02:04.260
如果我们快速滚动它，你可以看到有一个 for 循环

43
00:02:04.640 --> 00:02:08.889
只是发生了一些事情，然后就有了一个“如果”和“如果”

44
00:02:08.889 --> 00:02:12.320
还有另一个如果还有另一个如果还有另一个如果然后还有

45
00:02:12.320 --> 00:02:17.190
事情发生了，还有其他的事情，还有更多的如果，还有另一个如果

46
00:02:17.200 --> 00:02:22.130
嗯，现在我已经记不清我们在程式码中的位置了，

47
00:02:22.140 --> 00:02:23.450
发生了什么事。

48
00:02:23.540 --> 00:02:26.660
您可以看到压痕的程度相当大。

49
00:02:27.840 --> 00:02:30.660
这一点可以认真改进。

50
00:02:31.040 --> 00:02:32.860
那我们就从最上面开始吧

51
00:02:33.340 --> 00:02:38.350
我们取得布局并设定一些属性，并取得其他一些属性。

52
00:02:38.360 --> 00:02:41.800
我不在乎这有什么作用。确切地说，我不在乎这有什么作用。确切地。

53
00:02:41.800 --> 00:02:45.610
有些设置，有些获取，一切都很好很简单。

54
00:02:45.620 --> 00:02:47.760
但这里的结构有所不同

55
00:02:47.760 --> 00:02:49.670
我们循环播放背景影像。

56
00:02:49.670 --> 00:02:53.490
所以它为每个背景图像创建一个盒子，我

57
00:02:53.490 --> 00:02:56.560
认为将其分离为自己的功能是个好主意。

58
00:02:56.840 --> 00:02:59.380
所以我们在这个函数中有一个循环，然后调用

59
00:02:59.390 --> 00:03:02.820
为该特定图像建立框的函数。

60
00:03:02.960 --> 00:03:05.900
这样，当编写处理该图像的程式码时，

61
00:03:05.910 --> 00:03:07.630
我们甚至不必考虑

62
00:03:07.630 --> 00:03:10.760
事实上我们也在循环其他影像

63
00:03:11.240 --> 00:03:16.390
根据经验，但我想向函数传递尽可能少的信息

64
00:03:16.840 --> 00:03:20.220
这意味著您对该函数的内容有一个非常清晰的了解。

65
00:03:20.240 --> 00:03:22.750
例如，我可以传递整个上下文

66
00:03:22.860 --> 00:03:25.700
然后函数可以执行与此处相同的操作。

67
00:03:25.700 --> 00:03:28.450
它可以捕捉相机，可以从中获取其他东西，

68
00:03:28.940 --> 00:03:34.350
但我真的不知道那里正在使用什么。它甚至使用相机吗？

69
00:03:34.360 --> 00:03:37.960
它是否甚至使用多视图，无论它是什么。

70
00:03:38.640 --> 00:03:41.760
这就是为什么我喜欢明确地传递东西。

71
00:03:42.340 --> 00:03:46.890
我认为这个布局不会超出这两行，

72
00:03:46.890 --> 00:03:48.800
就像你在这里看不到任何亮点一样。

73
00:03:48.800 --> 00:03:54.760
所以我们假设它只是用来创建那个盒子，东西应该放进去。

74
00:03:55.240 --> 00:04:00.180
因此，我们将其保留在这里，仅将框传递给新函数。

75
00:04:00.400 --> 00:04:05.000
我想在这个类别上创建这个函数，以便将所有内容组合在一起。

76
00:04:05.040 --> 00:04:07.860
这意味著调用必须以 self 点开头

77
00:04:08.240 --> 00:04:11.250
因为它是此类的内部函数。

78
00:04:11.250 --> 00:04:16.670
它仅供我们私人使用，不适合从班级外部调用

79
00:04:17.089 --> 00:04:20.279
我想用底线表示。所以它以下划线开头

80
00:04:20.430 --> 00:04:24.460
它将绘制一张背景图像。所以我们就称它为

81
00:04:25.340 --> 00:04:25.760
快点

82
00:04:26.640 --> 00:04:27.660
背景图片

83
00:04:28.240 --> 00:04:29.950
那么它需要盒子。

84
00:04:30.340 --> 00:04:30.960
嗯，是吗，

85
00:04:31.740 --> 00:04:32.590
它使用盒子吗？

86
00:04:34.240 --> 00:04:35.900
它使用盒子。所以，是的，

87
00:04:36.090 --> 00:04:36.550
它

88
00:04:36.940 --> 00:04:40.020
我想需要 I 和 B G。

89
00:04:40.130 --> 00:04:43.150
我认为它也需要相机

90
00:04:44.540 --> 00:04:45.260
或者这样做，

91
00:04:46.340 --> 00:04:48.350
没有。不，事实并非如此。

92
00:04:48.740 --> 00:04:53.450
不突出显示仅在此处使用的营地名称，然后使用多视图，

93
00:04:53.460 --> 00:04:55.270
我认为他们用的是。

94
00:04:55.270 --> 00:04:56.860
所以确实需要这样

95
00:04:59.940 --> 00:05:01.160
我想就是这样。

96
00:05:02.640 --> 00:05:04.350
现在我们接到电话了，那就是

97
00:05:04.940 --> 00:05:07.660
把所有的程式码都放在那里，

98
00:05:09.840 --> 00:05:13.760
我们定义了这个函数，它也得到了它自己和其余的部分

99
00:05:14.340 --> 00:05:18.560
现在我们可以将所有其他程式码无意中提高一级。

100
00:05:20.040 --> 00:05:22.910
现在您已经看到的就是我们的优势

101
00:05:22.910 --> 00:05:26.290
不必寻找天气摄像头，

102
00:05:26.470 --> 00:05:30.180
我们可以看到这里使用的是它并没有传递给这个函数。

103
00:05:30.280 --> 00:05:33.930
这样我们就对这个变数的范围有了更好的理解

104
00:05:34.100 --> 00:05:37.490
这就是所有重构的目的，它更容易

105
00:05:37.490 --> 00:05:41.550
查看哪部分程式码需要哪部分资料。

106
00:05:42.340 --> 00:05:46.260
顺便说一句，我现在注意到的另一件事是，布局点是否处于活动状态？

107
00:05:46.640 --> 00:05:48.030
这不取决于我

108
00:05:48.240 --> 00:05:49.760
这不取决于BJ。

109
00:05:50.240 --> 00:05:53.360
所以它甚至不需要设定在这个 for 回圈中。

110
00:05:54.040 --> 00:05:56.650
并且没有所有混乱或其余代码，

111
00:05:57.240 --> 00:05:59.060
突然之间开始脱颖而出。

112
00:05:59.740 --> 00:06:04.790
因此，让我们将其一直移动到我们在布局上设置其他内容的位置，

113
00:06:04.800 --> 00:06:05.560
但后来

114
00:06:06.740 --> 00:06:11.370
我们需要这样的。好的，这已经很好地清理了这个函数。

115
00:06:11.390 --> 00:06:12.460
我们继续吧。

116
00:06:13.440 --> 00:06:18.040
所以在这里我们创建一行，一些事情的发生取决于它是否是一个

117
00:06:18.050 --> 00:06:21.130
影像或影片剪辑或呃呃这一切看起来都很简单，

118
00:06:21.130 --> 00:06:22.160
所以我就跳过它。

119
00:06:22.540 --> 00:06:28.360
嗯，那么这里我们唯一使用的是 I 参数。所以让我们给它一个更好的名字。

120
00:06:28.370 --> 00:06:31.260
按 Control D 选择两个实例，

121
00:06:32.540 --> 00:06:33.850
我们称之为图像索引。

122
00:06:33.860 --> 00:06:39.290
BG也是一个可疑的名字，我认为它太短了，但它被经常使用。

123
00:06:39.290 --> 00:06:41.060
我们暂时先不管它。

124
00:06:41.840 --> 00:06:43.160
所以这看起来不错。

125
00:06:43.740 --> 00:06:47.200
然后这里我们有如果 BG 点显示扩展

126
00:06:47.480 --> 00:06:51.370
我认为这就是那个扩大盒子的小三角形。

127
00:06:51.840 --> 00:06:54.410
大部头书。这意味著这里发生了两件事。

128
00:06:54.420 --> 00:06:57.060
正在绘制始终显示的框部分

129
00:06:57.440 --> 00:07:00.990
然后是盒子的可选扩展部分。

130
00:07:01.330 --> 00:07:03.680
对我来说这意味著绘制扩充的东西是

131
00:07:03.680 --> 00:07:06.260
不同的事物，因此属于不同的功能。

132
00:07:10.840 --> 00:07:15.850
那我们需要给它什么呢？显然我们需要这个盒子

133
00:07:16.240 --> 00:07:19.450
图像索引仅使用一次。所以我们不需要通过它。

134
00:07:19.840 --> 00:07:23.350
使用多视图尚未使用。所以它肯定会在下面的某个地方被使用。

135
00:07:23.840 --> 00:07:26.260
当然，我们需要背景图像本身

136
00:07:34.540 --> 00:07:35.950
然后是其余的代码

137
00:07:36.340 --> 00:07:38.390
又一个层次的强烈。

138
00:07:40.440 --> 00:07:43.860
现在你可以看到这个函数又变得更简单了。

139
00:07:44.240 --> 00:07:45.950
所以让我们继续更进一步。

140
00:07:46.740 --> 00:07:48.450
现在我们得到一些书。

141
00:07:51.630 --> 00:07:52.760
我不知道这意味著什么。

142
00:07:53.240 --> 00:07:53.860
呃

143
00:07:54.540 --> 00:07:56.920
那么如果来源影像那么

144
00:07:57.230 --> 00:07:58.260
东西

145
00:07:58.740 --> 00:08:01.260
否则，如果来源电影剪辑而不是东西。

146
00:08:01.640 --> 00:08:02.620
进而

147
00:08:03.000 --> 00:08:04.160
我们来看看房子的帐本。

148
00:08:06.440 --> 00:08:09.430
好吧，这又发生了一些不同的事情。

149
00:08:09.540 --> 00:08:13.850
它根据所选的来源进行选择，然后绘制一些内容。

150
00:08:14.240 --> 00:08:16.760
那么让我们再次使用同样的技巧。

151
00:08:19.520 --> 00:08:22.970
我们称之为绘制影像。这将

152
00:08:23.940 --> 00:08:27.680
可能不会使用这条路，因为它首先创建一个新行。

153
00:08:27.690 --> 00:08:34.490
所以它只会取得盒子和 PG 并使用多视图，然后我们可以使用这段程式码

154
00:08:34.640 --> 00:08:38.760
将其移到此处并缩进，以便我们可以再次找到它。

155
00:08:40.840 --> 00:08:41.559
我们到了。

156
00:08:41.940 --> 00:08:42.150
嗯。

157
00:08:43.140 --> 00:08:44.360
我们有一个函数。

158
00:08:45.340 --> 00:08:48.460
让我们忽略房屋帐簿。现在我们稍后再讨论这个问题。

159
00:08:49.440 --> 00:08:51.360
现在让我们对影片剪辑执行同样的操作。

160
00:08:54.640 --> 00:08:56.560
控制档 D 至

161
00:08:56.700 --> 00:08:57.850
复制该行

162
00:08:58.740 --> 00:09:00.450
全部向下移动它。

163
00:09:02.240 --> 00:09:03.050
重命名它，

164
00:09:03.640 --> 00:09:04.660
贴上程式码

165
00:09:05.540 --> 00:09:06.590
和一个印度人

166
00:09:07.040 --> 00:09:13.060
你现在已经可以看到我的 I D E 绘图使用深蓝色的多视图

167
00:09:13.440 --> 00:09:18.450
这意味著该参数甚至没有被使用。所以让我们删除它

168
00:09:19.040 --> 00:09:21.370
并且也从通话中删除。

169
00:09:21.940 --> 00:09:24.460
再一次，你可以看到事情开始变得清晰

170
00:09:24.840 --> 00:09:27.460
现在你可以看到你们大多数人只使用了

171
00:09:27.460 --> 00:09:30.320
用于绘制影像而不是错误的影片剪辑。

172
00:09:30.330 --> 00:09:33.400
请记住，我们尚未更改功能。

173
00:09:33.410 --> 00:09:36.890
我们刚刚移动了一些程式码行，但是它们的关系

174
00:09:36.890 --> 00:09:39.880
当谈到他们被执行的顺序时，

175
00:09:39.880 --> 00:09:41.060
他们获得哪些数据。

176
00:09:41.440 --> 00:09:42.960
一切还是一样。

177
00:09:43.340 --> 00:09:46.030
所以不了解它到底做了什么。

178
00:09:46.040 --> 00:09:48.500
我们已经可以做出所有这些改变。

179
00:09:48.940 --> 00:09:51.150
现在我们回到绘制图像函数

180
00:09:51.150 --> 00:09:54.250
因为你仍然可以看到它有双重发明

181
00:09:54.740 --> 00:09:59.870
我不喜欢这样。如果 b g 点影像不是无，那么

182
00:10:00.030 --> 00:10:02.660
否则会发生什么，什么事也不会发生。

183
00:10:03.340 --> 00:10:04.750
那为什么不把它翻转过来呢

184
00:10:06.240 --> 00:10:08.000
如果 BG 点影像为无

185
00:10:08.160 --> 00:10:08.760
返回，

186
00:10:09.340 --> 00:10:14.220
其中一个印度人更码。我们可以对视图做同样的事情。多视图。

187
00:10:14.230 --> 00:10:16.770
您可以将其放入不同的函数中，例如此博客

188
00:10:16.780 --> 00:10:20.500
专门用于绘制多视图选项，但您已经见过它了。

189
00:10:20.500 --> 00:10:24.850
所以让我们暂时跳过它。我认为还有更有趣的

190
00:10:25.400 --> 00:10:28.960
记住这一点。它曾经是一大块程式码。所以

191
00:10:29.540 --> 00:10:33.650
预设情况下，在某些特定情况下它被设定为 false

192
00:10:34.140 --> 00:10:35.220
它接受了真实的。

193
00:10:35.230 --> 00:10:37.900
这意味著这两个函数知道

194
00:10:37.900 --> 00:10:41.510
该函数现在不再知道的东西。

195
00:10:41.540 --> 00:10:45.750
换句话说，我们需要从绘制影像中获取一些资讯并绘制影片剪辑

196
00:10:46.140 --> 00:10:48.000
并得到回报

197
00:10:48.200 --> 00:10:49.110
到这个函数

198
00:10:49.340 --> 00:10:50.250
这就是关键所在。

199
00:10:50.250 --> 00:10:54.260
我们可以根据书的内容回传 true 或 false

200
00:10:55.340 --> 00:11:00.200
这里。它是如此的真实，也意味著在此之前它将是如此的虚假。

201
00:11:00.210 --> 00:11:03.330
所以我们声明这个函数回传一个

202
00:11:03.330 --> 00:11:06.860
布林值，这里我们可以回传 false 和

203
00:11:07.240 --> 00:11:08.560
在其他情况下

204
00:11:10.640 --> 00:11:12.040
我们可以直接回传true。

205
00:11:12.390 --> 00:11:15.050
现在我们已经完全消除了这个变量

206
00:11:15.440 --> 00:11:19.960
我们只是根据是否有可用图像返回 true 或 false

207
00:11:20.740 --> 00:11:23.040
同样的逻辑也适用于

208
00:11:23.190 --> 00:11:24.160
绘制影片剪辑。

209
00:11:26.840 --> 00:11:31.270
所以如果使用相机剪辑或BG点剪辑的话，那就是真的。

210
00:11:31.270 --> 00:11:34.320
否则它就会得到预设的 false。

211
00:11:34.340 --> 00:11:36.950
所以我们能做的是这样的，

212
00:11:37.740 --> 00:11:41.890
但当你设定了它，然后你又对其他不太好的东西说了一遍。

213
00:11:41.940 --> 00:11:45.560
当然我们也可以这样做，但这段程式码是什么意思呢？

214
00:11:45.560 --> 00:11:48.440
这意味著如果这个表达式为真

215
00:11:48.440 --> 00:11:51.640
变数变为真，如果该表达式为假，

216
00:11:51.650 --> 00:11:53.030
该变数变为 false。

217
00:11:53.110 --> 00:11:55.790
所以你可以这样做

218
00:11:56.340 --> 00:12:03.860
有书等于使用相机剪辑或剪辑，现在我们可以说返回，有书

219
00:12:05.740 --> 00:12:07.150
现在剩下的一切

220
00:12:07.540 --> 00:12:09.360
就是实际使用回传值

221
00:12:11.200 --> 00:12:13.280
我们又得到了这样的模式

222
00:12:13.550 --> 00:12:14.650
设定变数

223
00:12:14.810 --> 00:12:16.960
然后再次将其设定为其他内容，

224
00:12:17.340 --> 00:12:18.700
这不太好。

225
00:12:19.140 --> 00:12:22.480
所以我们能做的就是听听其他的

226
00:12:22.810 --> 00:12:24.830
结构开始变得有点

227
00:12:24.830 --> 00:12:27.790
根据影像来源的类型更清晰，

228
00:12:27.800 --> 00:12:32.130
我们绘制特定于该类型的东西，该函数会传回是否

229
00:12:32.260 --> 00:12:34.590
该图像实际上就在那里。

230
00:12:34.770 --> 00:12:35.850
所以也许

231
00:12:36.540 --> 00:12:38.100
我们应该重命名这个变数

232
00:12:38.500 --> 00:12:39.060
也

233
00:12:39.440 --> 00:12:41.970
作为来源，取决于来源，

234
00:12:41.980 --> 00:12:44.410
我们用它做一些事情，返回是否有

235
00:12:44.410 --> 00:12:46.840
是该类型的可用来源。

236
00:12:46.850 --> 00:12:48.840
我认为这已经清楚多了

237
00:12:49.050 --> 00:12:53.850
现在最后如果 has source 为 true，则执行此程式码，

238
00:12:53.860 --> 00:12:55.470
否则什么都不执行。

239
00:12:56.040 --> 00:12:57.850
这意味著我们可以说

240
00:12:57.950 --> 00:13:00.950
如果没有，则来源返回，因为工作已完成

241
00:13:01.180 --> 00:13:04.210
最后我们得到了这个 else 的来源是错的

242
00:13:04.940 --> 00:13:07.380
我们已经知道如果这是假的

243
00:13:07.380 --> 00:13:10.690
然后我们会返回以了解当您说预设时会发生什么，

244
00:13:10.690 --> 00:13:13.930
你必须继续阅读并思考正在发生的事情。

245
00:13:13.930 --> 00:13:18.260
我不喜欢那样。因此，让我们停止使用我们的大脑，只说否则返回。

246
00:13:19.140 --> 00:13:22.760
我认为现在我们有了更好的程式码，

247
00:13:23.440 --> 00:13:26.100
让我们再从头开始看一遍，我们有一个绘制函数，

248
00:13:26.480 --> 00:13:28.630
这个，它读取所有背景图像

249
00:13:28.980 --> 00:13:29.870
创建一个盒子

250
00:13:30.340 --> 00:13:31.210
并填满盒子

251
00:13:31.740 --> 00:13:32.360
而且简单。

252
00:13:32.840 --> 00:13:35.000
其余的程式码也同样简单。

253
00:13:35.160 --> 00:13:38.660
现在，如果我们滚动它，请注意缩排级别，

254
00:13:39.640 --> 00:13:41.950
你可以看到班级有缩排

255
00:13:41.950 --> 00:13:45.060
for 函数，然后 for 一个条件或循环

256
00:13:45.740 --> 00:13:46.590
就是这样。

257
00:13:47.740 --> 00:13:50.460
我们的程式码完全扁平化了。

258
00:13:50.840 --> 00:13:54.860
没有条件嵌套，这一切都更容易理解。

259
00:13:55.940 --> 00:14:00.290
所以我们所做的其实是降低了他们所说的认知复杂性。

260
00:14:00.300 --> 00:14:05.860
这是一个指标，可以为您提供特定代码复杂程度的评分。基本上。

261
00:14:05.860 --> 00:14:09.560
它惩罚条件内的条件内的条件，

262
00:14:10.140 --> 00:14:12.960
您在另一点新增的每个条件

263
00:14:13.440 --> 00:14:20.160
加上您放置它的位置的嵌套层级。因此，如果在 F 内，则可获得 3 分。

264
00:14:20.640 --> 00:14:21.930
两个代表两个如果。

265
00:14:21.940 --> 00:14:26.050
因为第二个 if 在另一个 if 之内，如果它得到另一个点，

266
00:14:26.280 --> 00:14:27.080
我会告诉你

267
00:14:27.230 --> 00:14:30.060
这里。我们有一个简单的功能。分数为零。

268
00:14:30.440 --> 00:14:33.760
这里我们有一个得分函数。一是因为它只有一个条件

269
00:14:34.240 --> 00:14:39.250
直到我们有一个巢状条件的函数。所以这得三分

270
00:14:39.740 --> 00:14:42.010
初始条件加一

271
00:14:42.400 --> 00:14:44.090
并加上两个嵌套。

272
00:14:44.090 --> 00:14:47.940
+11 表示条件本身，1 表示它是嵌套的。

273
00:14:48.170 --> 00:14:50.170
如果你要嵌套另一个会得到

274
00:14:50.180 --> 00:14:52.250
两个用于嵌套，一个用于条件。

275
00:14:52.940 --> 00:14:56.560
因此，透过减少所有这些程式码的嵌套级别，

276
00:14:56.570 --> 00:15:00.860
我们确实降低了这个特定的复杂性指标。

277
00:15:01.440 --> 00:15:04.640
我们已经完成了这一集的艺术家脚本编写工作。

278
00:15:04.650 --> 00:15:07.040
我希望您已经了解了一些如何

279
00:15:07.040 --> 00:15:10.230
将您的程式码修改为更具可读性并获得

280
00:15:10.230 --> 00:15:12.700
对单独放置什么有更多的感觉

281
00:15:12.700 --> 00:15:15.270
函数以及在同一函数中保留什么。

282
00:15:15.550 --> 00:15:17.420
关于这个还有很多要说的

283
00:15:17.420 --> 00:15:20.660
我确信我会在以后的影片中介绍这一点。

284
00:15:20.670 --> 00:15:22.050
非常感谢您的观看。