WEBVTT

1
00:00:00.000 --> 00:00:02.360
您好，欢迎来到艺术家脚本。

2
00:00:02.460 --> 00:00:06.380
我叫 Sybren，今天我们将学习 for 和 while 回圈。

3
00:00:06.780 --> 00:00:10.500
Roger 在 Twitter 上问道，我看到你有 for 回圈。

4
00:00:10.640 --> 00:00:12.820
什么时候使用 while 回圈比较好？

5
00:00:13.260 --> 00:00:16.240
我认为这是一个非常好的问题，所以让我们来看看。

6
00:00:16.620 --> 00:00:20.020
因此，在本影片中，我们首先将了解 for 回圈和 while 回圈。

7
00:00:20.060 --> 00:00:20.820
效果如何？

8
00:00:20.980 --> 00:00:22.460
他们之间有什么区别？

9
00:00:23.420 --> 00:00:27.500
我们之前已经看过 for 循环，所以我们将再看一下 while 循环

10
00:00:27.501 --> 00:00:31.238
看看你会使用它们的几个原因，我

11
00:00:31.239 --> 00:00:34.100
将介绍更多控制循环的方法。

12
00:00:34.780 --> 00:00:38.580
因为这个问题比较抽象，所以我们就从比较抽象的方式开始。

13
00:00:39.000 --> 00:00:42.320
几分钟后，我们将看到一个结合了 for 的具体范例

14
00:00:42.321 --> 00:00:44.847
和 while 循环，但首先让我们来看看

15
00:00:44.848 --> 00:00:47.721
将它们放在一起，看看它们有何不同。

16
00:00:48.500 --> 00:00:51.452
我们已经看到了一堆 for 循环，所以

17
00:00:51.453 --> 00:00:55.341
它们看起来像是一个东西和一堆东西。

18
00:00:57.760 --> 00:01:02.921
而 while 回圈则略有不同，它更简单，而且看起来有点像 if。

19
00:01:07.260 --> 00:01:09.675
for 回圈迭代了一堆东西，

20
00:01:09.676 --> 00:01:12.780
迭代基本上意味著请询问下一个。

21
00:01:13.640 --> 00:01:17.640
当您有一系列事物（例如选定的物件或

22
00:01:17.641 --> 00:01:21.340
数字 0 到 600，就像我们在猴子网格中看到的那样。

23
00:01:21.920 --> 00:01:23.260
while 回圈更原始。

24
00:01:23.460 --> 00:01:27.240
不要问“下一步”并期望 Python 能够理解并提供

25
00:01:27.241 --> 00:01:30.480
接下来，它询问我应该继续循环吗？

26
00:01:30.880 --> 00:01:32.848
当你想保留时这非常有用

27
00:01:32.849 --> 00:01:35.921
重复直到到达某个点。

28
00:01:36.200 --> 00:01:38.664
另一种思考方式，正如我已经提到的，它看起来

29
00:01:38.665 --> 00:01:41.800
就像 if 一样，它基本上是一个重复的 if 语句。

30
00:01:43.040 --> 00:01:44.864
所以你已经看过很多例子了

31
00:01:44.865 --> 00:01:46.780
for 回圈，所以让我们来看看 while 回圈。

32
00:01:47.520 --> 00:01:53.660
假设您想要简化网格直到它具有 10,000 个或更多顶点。

33
00:01:54.380 --> 00:01:55.900
所以这将是一种方法。

34
00:01:55.920 --> 00:01:57.920
我们可以先开始查看网格，

35
00:02:01.190 --> 00:02:07.910
这是由 bpy 上下文、活动物件点资料提供给我们的。

36
00:02:09.210 --> 00:02:13.054
网格有顶点，我们可以检查

37
00:02:13.055 --> 00:02:16.050
的长度来取得顶点的数量。

38
00:02:16.051 --> 00:02:19.650
因此，在本例中，Suzanne 有 507 个顶点。

39
00:02:20.330 --> 00:02:23.322
要细分，我们需要进入编辑模式，但是物件点

40
00:02:23.323 --> 00:02:26.390
资料只有在我们再次退出编辑模式后才会更新。

41
00:02:26.830 --> 00:02:29.170
所以这意味著我们的程式码必须执行以下操作。

42
00:02:31.850 --> 00:02:36.097
首先我们进入编辑模式，然后选择所有内容

43
00:02:36.098 --> 00:02:39.111
现在，但只是为了确保我们选择了所有内容。

44
00:02:40.790 --> 00:02:45.910
然后我们细分，然后我们回到物件模式。

45
00:02:46.590 --> 00:02:50.650
现在，当我们查看 len 网格点顶点时，我们可以看到它有

46
00:02:50.651 --> 00:02:54.130
增加，因为编辑资料已刷新回实际网格。

47
00:02:55.470 --> 00:02:56.770
因此，让我们将其放入脚本中。

48
00:02:57.570 --> 00:02:58.850
让我们摆脱这个吧。

49
00:02:59.910 --> 00:03:02.830
从 import bpy 开始，然后从取得网格开始。

50
00:03:04.230 --> 00:03:09.610
然后我总是做的事，好吧不是总是做，但我有时会做的事

51
00:03:09.611 --> 00:03:12.185
不太确定我的 while 循环，因为

52
00:03:12.186 --> 00:03:14.410
存在无限循环的风险。

53
00:03:14.870 --> 00:03:18.480
如果你说虽然正确，那么正确就永远正确，

54
00:03:18.481 --> 00:03:21.651
这里的程式码将永远重复。

55
00:03:22.710 --> 00:03:25.010
这不太好，因为它实际上会出错。

56
00:03:26.510 --> 00:03:28.790
所以不要写 while，而是写 if。

57
00:03:31.900 --> 00:03:40.520
所以如果顶点数小于10000，我们就需要进行细分。

58
00:03:41.040 --> 00:03:43.860
现在我们只能测试一个细分。

59
00:03:44.220 --> 00:03:47.074
如果可行的话，我们可以将 f 改为 a

60
00:03:47.075 --> 00:03:51.081
while 并循环直到我们需要停止。

61
00:03:51.460 --> 00:03:53.500
所以我们需要进入编辑模式。

62
00:03:53.980 --> 00:03:58.460
因此，将滑鼠悬停在那里，按住 ctrl C 和 ctrl V。

63
00:03:59.600 --> 00:04:04.060
然后，一旦进入编辑模式，我们需要选择所有内容以确保确定。

64
00:04:04.280 --> 00:04:07.340
将滑鼠悬停并按 ctrl C，然后在此处按 ctrl V。

65
00:04:12.900 --> 00:04:18.260
然后进行细分，悬停，ctrl C，还有ctrl V。

66
00:04:19.460 --> 00:04:22.140
然后我们回到物件模式。

67
00:04:26.470 --> 00:04:28.130
这应该有效。

68
00:04:28.170 --> 00:04:28.890
著名的最后一句话。

69
00:04:29.010 --> 00:04:32.370
所以我们从物件模式下的物件开始。

70
00:04:35.440 --> 00:04:39.260
你看，它已经完成了一级细分，我们可以继续下去。

71
00:04:39.960 --> 00:04:42.840
现在您可以看到该程式码不再有效。

72
00:04:43.340 --> 00:04:44.360
这是为什么呢？

73
00:04:44.980 --> 00:04:50.660
嗯，顶点数超过10000，就停止细分了。

74
00:04:51.380 --> 00:04:58.500
这告诉我们，一旦我们把f改成a，它也会停止。

75
00:05:01.060 --> 00:05:03.300
正如您所看到的，该程式码没有执行任何操作。

76
00:05:04.040 --> 00:05:08.520
这意味著首先检查此条件。

77
00:05:08.940 --> 00:05:10.860
所以它位于循环的顶部。

78
00:05:11.380 --> 00:05:13.400
因此，首先对其进行检查是有道理的。

79
00:05:14.420 --> 00:05:15.480
所以首先是检查。

80
00:05:15.740 --> 00:05:18.800
如果检查为真，则进行循环迭代。

81
00:05:18.801 --> 00:05:20.880
话又说回来，还有一张支票。

82
00:05:21.160 --> 00:05:24.580
如果检查为真，则会进行另一个循环迭代，依此类推。

83
00:05:25.160 --> 00:05:30.760
因此，让我们扔掉这个苏珊娜并添加一个新的。

84
00:05:31.340 --> 00:05:36.560
现在我们单击一次，我们将立即得到最终的细分级别。

85
00:05:37.120 --> 00:05:40.880
这就是如何使用 while 循环直到满足某些条件。

86
00:05:41.480 --> 00:05:44.540
所以我已经提到可以创建无限循环。

87
00:05:44.840 --> 00:05:48.680
我将向您展示一种控制迭代次数的方法。

88
00:05:48.681 --> 00:05:50.080
作为一种安全网。

89
00:05:50.780 --> 00:05:53.660
这可能对您的情况没有用，甚至可能有点过分。

90
00:05:53.720 --> 00:05:56.080
但无论如何，它都是您工具箱中的一个不错的工具。

91
00:05:57.180 --> 00:05:59.700
所以我们要限制的是细分的数量。

92
00:06:00.380 --> 00:06:02.260
所以让我们来数一下它们。

93
00:06:03.860 --> 00:06:05.240
我们从零开始计数。

94
00:06:06.900 --> 00:06:08.440
我们暂时保留程式码不变。

95
00:06:08.500 --> 00:06:11.260
最后我们说。

96
00:06:13.100 --> 00:06:14.700
细分加等于一。

97
00:06:15.280 --> 00:06:20.401
而这意味著细分完成后，给细分加一。

98
00:06:20.460 --> 00:06:22.120
我们继续循环。

99
00:06:23.320 --> 00:06:24.360
到目前为止我们只计算。

100
00:06:24.500 --> 00:06:25.820
我们还没有对此做出回应。

101
00:06:25.860 --> 00:06:28.600
当细分变得太大时，循环不会中断。

102
00:06:29.360 --> 00:06:34.260
所以它需要在顶点数仍然太少的情况下继续循环。

103
00:06:34.320 --> 00:06:35.320
当然。

104
00:06:39.120 --> 00:06:40.160
而同时...

105
00:06:40.700 --> 00:06:42.840
我会把它做得小一点。

106
00:06:44.320 --> 00:06:46.520
而细分则少于三。

107
00:06:47.560 --> 00:06:49.660
所以现在只会细分三次。

108
00:06:49.900 --> 00:06:52.580
对于细分，它是零、一和二。

109
00:06:53.820 --> 00:06:56.400
所有这些时间细分都小于三。

110
00:06:57.020 --> 00:07:00.120
一旦我们完成了第三个，细分将是三个。

111
00:07:00.240 --> 00:07:01.520
这意味著循环将会中断。

112
00:07:02.200 --> 00:07:04.317
现在我们正在计算的情况

113
00:07:04.318 --> 00:07:07.200
事情，我们实际上可以将其重写为 for 循环。

114
00:07:07.580 --> 00:07:10.020
与我们创建猴子网格时的方式大致相同。

115
00:07:11.140 --> 00:07:15.400
因此，我们不要自己追踪细分数量。

116
00:07:15.720 --> 00:07:19.580
我们可以说对于范围三中的细分。

117
00:07:21.180 --> 00:07:24.200
而这只会做三次。

118
00:07:25.500 --> 00:07:27.737
所以我们现在唯一需要做的就是停止

119
00:07:27.738 --> 00:07:30.761
如果顶点数量够大，则尽早。

120
00:07:31.300 --> 00:07:35.760
所以不要说顶点数小于某个数。

121
00:07:35.761 --> 00:07:44.660
我们说顶点数是否大于或等于该数。

122
00:07:44.700 --> 00:07:46.580
所以我们翻转条件。

123
00:07:48.740 --> 00:07:49.840
我们跳出循环。

124
00:07:50.560 --> 00:07:53.940
Break 意味著立即停止该循环。

125
00:07:54.100 --> 00:07:56.260
不要在该体内执行任何其他操作。

126
00:07:56.540 --> 00:07:57.840
摆脱它。

127
00:08:00.760 --> 00:08:02.040
然后我们可以删除它。

128
00:08:02.120 --> 00:08:03.340
我们可以删除这个。

129
00:08:04.140 --> 00:08:05.480
这里我们又得到了我们的程式码。

130
00:08:06.120 --> 00:08:09.300
所以我们用 for 来代替 while。

131
00:08:09.500 --> 00:08:11.860
我们将条件从 while 移至 if。

132
00:08:12.680 --> 00:08:16.260
for 确保这种情况只发生三次。

133
00:08:16.580 --> 00:08:18.560
那么让我们来看看它是什么样子的。

134
00:08:21.940 --> 00:08:23.260
让我们从新鲜的苏珊娜开始。

135
00:08:25.820 --> 00:08:30.160
我们不能重复使用这个网格，因为它仍然引用旧的网格。

136
00:08:30.161 --> 00:08:39.280
假设 len context.object.data .vertices 507。

137
00:08:40.060 --> 00:08:42.000
我们现在执行这段程式码。

138
00:08:44.520 --> 00:08:47.320
现在我们可以看到结果是完全一样的。

139
00:08:47.520 --> 00:08:51.340
这是我们所期望的，因为它达到了数量的限制

140
00:08:51.341 --> 00:08:53.462
到达极限之前的顶点

141
00:08:53.463 --> 00:08:55.880
允许进行的细分数量。

142
00:08:56.180 --> 00:08:58.840
那么让我们来试试新鲜的苏珊娜。

143
00:08:59.580 --> 00:09:03.540
并将此限制设为一百万。

144
00:09:04.280 --> 00:09:07.858
三分钟内可能不会达到一百万个顶点

145
00:09:07.859 --> 00:09:11.160
细分，所以我们最终应该得到更少的东西。

146
00:09:13.540 --> 00:09:16.100
我们又得到了完全相同的结果。

147
00:09:16.780 --> 00:09:19.840
让我们增加细分数量的限制。

148
00:09:23.060 --> 00:09:24.000
从新鲜的苏珊娜开始。

149
00:09:24.001 --> 00:09:33.040
它又做了一个细分，但没有达到那一百万，因为我们

150
00:09:33.041 --> 00:09:36.000
对其允许进行的细分数量有限制。

151
00:09:36.740 --> 00:09:41.180
因此，这是另一种将 while 回圈重写为 for 回圈和 if 的方法。

152
00:09:41.780 --> 00:09:45.120
然后它的迭代次数就会受到限制。

153
00:09:46.200 --> 00:09:48.820
这就是本期《艺术家脚本》的内容。

154
00:09:48.920 --> 00:09:50.750
如果您有任何疑问或意见请

155
00:09:50.751 --> 00:09:53.361
请在下面发表评论，我们很快就会见到你。