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
請在下面發表評論，我們很快就會見到你。