Tương tự với mã c
Bạn đang tưởng tượng rằng
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
for [int i = 0; i < 10; i++]
if [i == 5]
i += 3;
Nó giống như mã C này:
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
Vì vậy, việc sửa đổi
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
Ví dụ tháo gỡ
Bạn có thể nhìn vào việc tháo gỡ mã Python để xem điều này:
>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
Phần này tạo ra một phạm vi từ 0 đến 10 và nhận ra nó:
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
Tại thời điểm này, đỉnh của ngăn xếp chứa phạm vi.
Điều này nhận được một trình lặp trên đối tượng trên đỉnh của ngăn xếp, tức là phạm vi:
15 GET_ITER
Tại thời điểm này, đỉnh của ngăn xếp chứa một trình lặp qua phạm vi nhận ra.
For_iter bắt đầu lặp lại trên vòng lặp bằng cách sử dụng trình lặp ở đầu estack:
>> 16 FOR_ITER 36 [to 55]
Tại thời điểm này, phần trên của ngăn xếp chứa giá trị tiếp theo của trình lặp.
Và ở đây bạn có thể thấy rằng đỉnh của ngăn xếp được bật và gán cho
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
19 STORE_FAST 0 [i]
Vì vậy,
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
Đây là một cái nhìn tổng quan về các máy ngăn xếp nếu bạn chưa thấy điều này trước đây.
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Đối với các vòng lặp trong Python [Lặp lại xác định] This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: For Loops in Python [Definite Iteration]
Hướng dẫn này sẽ chỉ cho bạn cách thực hiện lần lặp xác định với vòng lặp Python
15 GET_ITER
15 GET_ITER
Trong hướng dẫn trước đây trong loạt giới thiệu này, bạn đã học được như sau:
- Việc thực hiện lặp đi lặp lại của cùng một khối mã lặp đi lặp lại được gọi là lặp.iteration.
- Có hai loại lặp:
- Lặp lại xác định, trong đó số lần lặp lại được chỉ định trước iteration, in which the number of repetitions is specified explicitly in advance
- Lặp lại không xác định, trong đó khối mã thực thi cho đến khi một số điều kiện được đáp ứng iteration, in which the code block executes until some condition is met
- Trong Python, lần lặp không xác định được thực hiện với vòng lặp
2.15 GET_ITER
Ở đây, những gì bạn bao gồm trong hướng dẫn này:
Bạn sẽ bắt đầu với việc so sánh một số mô hình khác nhau được sử dụng bởi các ngôn ngữ lập trình để thực hiện lặp lại xác định.
Sau đó, bạn sẽ tìm hiểu về Iterables và Iterators, hai khái niệm tạo thành cơ sở của việc lặp lại xác định trong Python.iterables and iterators, two concepts that form the basis of definite iteration in Python.
-
Cuối cùng, bạn sẽ gắn kết tất cả lại với nhau và tìm hiểu về các vòng lặp Python, ____41.
Một cuộc khảo sát về lặp lại xác định trong lập trình
Các vòng lặp xác định thường được gọi là các vòng
15 GET_ITER
15 GET_ITER
15 GET_ITER
15 GET_ITER
Trong lịch sử, các ngôn ngữ lập trình đã cung cấp một vài hương vị của vòng lặp
15 GET_ITER
Vòng lặp phạm vi số
Vòng lặp
15 GET_ITER
for i = 1 to 10
Ở đây, cơ thể của vòng lặp được thực hiện mười lần. Biến
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
15 GET_ITER
Vòng lặp ba biểu hiện
Một dạng khác của vòng lặp
15 GET_ITER
- Một khởi tạo
- Một biểu thức chỉ định một điều kiện kết thúc
- Một hành động được thực hiện ở cuối mỗi lần lặp.
Loại vòng lặp này có hình thức sau:
for [i = 1; i > 16 FOR_ITER 36 [to 55]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
Các vòng lặp ba biểu hiện
15 GET_ITER
15 GET_ITER
Vòng lặp dựa trên bộ sưu tập hoặc dựa trên vòng lặp
Loại vòng lặp này lặp lại trên một tập hợp các đối tượng, thay vì chỉ định các giá trị hoặc điều kiện số:
for i in
Mỗi lần thông qua vòng lặp, biến
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
19 STORE_FAST 0 [i]
15 GET_ITER
19 STORE_FAST 0 [i]
15 GET_ITER
Vòng lặp Python 15 GET_ITER
1
15 GET_ITER
Trong số các loại vòng được liệt kê ở trên, Python chỉ thực hiện lần lặp lại cuối cùng: Lặp lại dựa trên bộ sưu tập. Lúc đầu, điều đó có vẻ như là một thỏa thuận thô, nhưng hãy yên tâm rằng việc thực hiện Python, việc lặp lại xác định rất linh hoạt đến nỗi bạn đã giành được cảm giác bị lừa!
Một thời gian ngắn, bạn sẽ đào sâu vào các ruột của Python từ
15 GET_ITER
Vòng lặp Python từ
15 GET_ITER
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
19 STORE_FAST 0 [i]
19 STORE_FAST 0 [i]
19 STORE_FAST 0 [i]
for i = 1 to 10
19 STORE_FAST 0 [i]
Đây là một ví dụ đại diện:
>>>
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
Trong ví dụ này,
19 STORE_FAST 0 [i]
for i = 1 to 10
for i = 1 to 10
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
for i = 1 to 10
for i = 1 to 10
for [i = 1; i def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
Vòng lặp này có thể được mô tả hoàn toàn theo các khái niệm bạn vừa biết. Để thực hiện lần lặp lại vòng lặp
15 GET_ITER
Gọi
for [i = 1; i >>>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
1Vòng lặp này có thể được mô tả hoàn toàn theo các khái niệm bạn vừa biết. Để thực hiện lần lặp lại vòng lặp
15 GET_ITER
1 này mô tả, Python làm như sau:>>>
>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
2Vòng lặp này có thể được mô tả hoàn toàn theo các khái niệm bạn vừa biết. Để thực hiện lần lặp lại vòng lặp
15 GET_ITER
1 này mô tả, Python làm như sau:
>>>
>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
3Vòng lặp này có thể được mô tả hoàn toàn theo các khái niệm bạn vừa biết. Để thực hiện lần lặp lại vòng lặp
15 GET_ITER
1 này mô tả, Python làm như sau:>>>
>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
4Vòng lặp này có thể được mô tả hoàn toàn theo các khái niệm bạn vừa biết. Để thực hiện lần lặp lại vòng lặp
15 GET_ITER
1 này mô tả, Python làm như sau:>>>
>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
5Vòng lặp này có thể được mô tả hoàn toàn theo các khái niệm bạn vừa biết. Để thực hiện lần lặp lại vòng lặp 15 GET_ITER
1 này mô tả, Python làm như sau:
15 GET_ITER
Gọi
for [i = 1; i >>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
6Vòng lặp này có thể được mô tả hoàn toàn theo các khái niệm bạn vừa biết. Để thực hiện lần lặp lại vòng lặp
15 GET_ITER
1 này mô tả, Python làm như sau:Gọi
for [i = 1; i >>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
7Lưu ý rằng
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
28 trả về một đối tượng của lớp int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
38, không phải là danh sách hoặc tuple của các giá trị. Bởi vì một đối tượng int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
38 là một điều có thể đi được, bạn có thể thu được các giá trị bằng cách lặp lại chúng bằng một vòng lặp 15 GET_ITER
1:>>>
>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
8Bạn cũng có thể lấy tất cả các giá trị cùng một lúc với
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
01 hoặc int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
03. Trong một phiên thay thế, đó có thể là một cách thuận tiện để nhanh chóng hiển thị các giá trị là gì:>>>
>>> from dis import dis
>>> def foo[]:
... for i in range [0,10]:
... if i==5:
... i+=3
... print i
...
>>> dis[foo]
2 0 SETUP_LOOP 53 [to 56]
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
15 GET_ITER
>> 16 FOR_ITER 36 [to 55]
19 STORE_FAST 0 [i]
3 22 LOAD_FAST 0 [i]
25 LOAD_CONST 3 [5]
28 COMPARE_OP 2 [==]
31 POP_JUMP_IF_FALSE 47
4 34 LOAD_FAST 0 [i]
37 LOAD_CONST 4 [3]
40 INPLACE_ADD
41 STORE_FAST 0 [i]
44 JUMP_FORWARD 0 [to 47]
5 >> 47 LOAD_FAST 0 [i]
50 PRINT_ITEM
51 PRINT_NEWLINE
52 JUMP_ABSOLUTE 16
>> 55 POP_BLOCK
>> 56 LOAD_CONST 0 [None]
59 RETURN_VALUE
>>>
9Tuy nhiên, khi
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
28 được sử dụng trong mã là một phần của ứng dụng lớn hơn, nó thường được coi là thực hành kém để sử dụng int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
01 hoặc int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
03 theo cách này. Giống như trình lặp, các đối tượng int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
38 là lười biếng, các giá trị trong phạm vi được chỉ định không được tạo cho đến khi chúng được yêu cầu. Sử dụng int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
01 hoặc int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
03 trên đối tượng int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
38 buộc tất cả các giá trị sẽ được trả về cùng một lúc. Điều này hiếm khi cần thiết, và nếu danh sách dài, nó có thể lãng phí thời gian và trí nhớ.int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
50 trả về một số lượng có thể mang lại số nguyên bắt đầu bằng int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
51, cho đến nhưng không bao gồm int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
36. Nếu được chỉ định, int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
53 cho biết số lượng bỏ qua giữa các giá trị [tương tự với giá trị sải chân được sử dụng cho chuỗi và cắt danh sách]:>>>
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
0Nếu
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
53 bị bỏ qua, nó mặc định là 15 GET_ITER
9:
>>>
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
1Tất cả các tham số được chỉ định cho
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
28 phải là số nguyên, nhưng bất kỳ tham số nào có thể âm. Đương nhiên, nếu int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
51 lớn hơn int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
36, int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
53 phải âm [nếu bạn muốn có bất kỳ kết quả nào]:>>>
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
2
Thay đổi hành vi vòng lặp 15 GET_ITER
1
15 GET_ITER
Bạn đã thấy trong hướng dẫn trước đây trong loạt giới thiệu này làm thế nào việc thực hiện vòng lặp
15 GET_ITER
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
15 GET_ITER
Các câu lệnh int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
62 và int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
63
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
15 GET_ITER
15 GET_ITER
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
>>>
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
>>>
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
Điều khoản int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
64
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
Một vòng lặp
15 GET_ITER
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
15 GET_ITER
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
>>>
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
Điều khoản
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
int r[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for [int j = 0; j < sizeof[r]/sizeof[r[0]]; j++] {
int i = r[j];
if [i == 5]
i += 3;
}
>>>
3 LOAD_GLOBAL 0 [range]
6 LOAD_CONST 1 [0]
9 LOAD_CONST 2 [10]
12 CALL_FUNCTION 2
Sự kết luận
Hướng dẫn này đã trình bày vòng lặp
15 GET_ITER
Bạn cũng đã tìm hiểu về các hoạt động bên trong của các phép lặp và lặp, hai loại đối tượng quan trọng làm nền tảng cho phép lặp xác định, nhưng cũng nổi bật trong một loạt các mã Python khác.iterables and iterators, two important object types that underlie definite iteration, but also figure prominently in a wide variety of other Python code.
Trong hai hướng dẫn tiếp theo trong chuỗi giới thiệu này, bạn sẽ chuyển bánh răng một chút và khám phá cách các chương trình Python có thể tương tác với người dùng thông qua đầu vào từ bàn phím và đầu ra vào bảng điều khiển.input from the keyboard and output to the console.
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Đối với các vòng lặp trong Python [Lặp lại xác định] This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: For Loops in Python [Definite Iteration]
Bạn có thể đặt một vòng lặp cho một biến không?
Thông thường biến điều khiển A For For Loop chỉ cần cho các mục đích của vòng lặp và không được sử dụng ở nơi khác. Khi đây là trường hợp, có thể khai báo biến bên trong phần khởi tạo của FOR.it is possible to declare the variable inside the initialization portion of the for.
Bạn có thể đặt một vòng lặp trong một chức năng Python không?
Chúng ta có thể sử dụng hàm phạm vi [] trong các vòng lặp để lặp lại thông qua một chuỗi các số.Nó có thể được kết hợp với hàm Len [] để lặp lại thông qua một chuỗi bằng cách sử dụng lập chỉ mục.. It can be combined with the len[] function to iterate through a sequence using indexing.
Làm thế nào để bạn thực hiện một vòng lặp với hai biến?
Có, tôi có thể khai báo nhiều biến trong vòng lặp.Và bạn cũng vậy, giờ đây có thể khai báo nhiều biến, trong một vòng lặp, như sau: Chỉ cần tách nhiều biến trong câu lệnh khởi tạo với dấu phẩy.Đừng quên kết thúc câu lệnh khởi tạo hoàn chỉnh với dấu chấm phẩy.separate the multiple variables in the initialization statement with commas. Do not forget to end the complete initialization statement with a semicolon.
Một vòng lặp có thể có hai biến python không?
Việc sử dụng nhiều biến trong vòng lặp For trong Python có thể được áp dụng cho danh sách hoặc từ điển, nhưng nó không hoạt động cho một lỗi chung.Nhiều bài tập của các biến này đồng thời, trong cùng một dòng mã, được gọi là không thể giải nén được.. These multiple assignments of variables simultaneously, in the same line of code, are known as iterable unpacking.