Sự khác biệt thực sự khá tinh tế. Cả hai vòng lặp và lặp đều được sử dụng để lặp lại một đoạn mã. Vòng lặp là một ý tưởng cổ xưa, chúng tồn tại từ lâu trước khi máy tính làm. Hầu như mọi ngôn ngữ lập trình đều có một số loại vòng lặp. Trình lặp là tương đối mới và chúng chỉ tồn tại trong một vài ngôn ngữ như Ruby.
Các vòng lặp đều mạnh mẽ vừa nguy hiểm: nó quá dễ dàng để phá vỡ chương trình của bạn bằng cách tạo ra một vòng lặp được gọi là vô hạn, nếu bạn không đảm bảo rằng điều kiện chấm dứt [một điều phải là
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
5 để vòng lặp dừng] thực sự xảy ra. Chẳng hạn, tôi đã cố gắng đếm từ một số [mà người dùng đã nhập] đến 100 bước trong 10:termination condition [the one that must be words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
5 so the loop stops] really occurs. For instance, I was trying to count from a number [that the user entered] to 100 in steps of 10:number = gets.chomp.to_i
while number != 100
puts number += 10
end
Bạn có thấy vấn đề? Nếu người dùng gõ bằng
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
6, chúng tôi có một vòng lặp vô hạn. Ối. OK, điều này thực sự dễ dàng để sửa chữa [chỉ cần thay đổi điều kiện vòng lặp thành words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
7 thay thế], nhưng bạn có được điểm. Thay vào đó, một vòng lặp vô hạn là không thể nếu chúng ta sử dụng trình lặp thay thế: thay vào đó: [number..100].step[10].each {|n| puts n}
Nhưng đó không phải là điều tốt duy nhất về Iterators. Chúng cũng cho phép bạn viết mã biểu cảm, không lộn xộn hơn. Bởi vì họ trừu tượng ra khỏi các chi tiết nitty-gritty của một vòng lặp. So sánh một mình:
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
Cả hai phần của mã thực hiện chính xác cùng một nhiệm vụ. Nhưng cái nào dễ viết, đọc và hiểu?
Tương tự, với
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
8, người lặp có lẽ nổi tiếng nhất trong tất cả:words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
Cuối cùng, bạn có thể xác định các trình lặp tùy chỉnh cho các nhu cầu vòng lặp đặc biệt của mình và Ruby cung cấp một số loại tích hợp tuyệt vời:
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
Cố gắng làm điều tương tự với một vòng lặp
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
9 và bạn sẽ thấy việc lặp lại như thế nào. 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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0.definite iteration with a Python list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 loop.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
9.words = ["one", "two", "three", "four"] # loop vs. iterator i = 0 words.each do |w| while i < words.length puts words[i] puts w i += 1 end end
Ở đâ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.
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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 vì list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 là từ khóa được sử dụng để giới thiệu chúng trong gần như tất cả các ngôn ngữ lập trình, bao gồm cả Python.list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 loops because list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 is the
keyword that is used to introduce them in nearly all programming languages, including Python.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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0. Đây được mô tả ngắn gọn trong các phần sau.Vòng lặp phạm vi số
Vòng lặp
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 cơ bản nhất là một câu lệnh phạm vi số đơn giản với các giá trị bắt đầu và kết thúc. Định dạng chính xác khác nhau tùy thuộc vào ngôn ngữ nhưng thường trông giống như thế này: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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 giả định giá trị list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
8 trên lần lặp thứ nhất, list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
9 trên thứ hai, v.v. Loại vòng list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này được sử dụng trong các ngôn ngữ Basic, algol và pascal.Vòng lặp ba biểu hiện
Một dạng khác của vòng lặp
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 được phổ biến bởi ngôn ngữ lập trình C chứa ba phần:- 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 ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 đến list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
8.for i = 1 to 10
4.list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 bằng list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
8 sau mỗi lần lặp lại vòng lặp.Các vòng lặp ba biểu hiện
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 rất phổ biến vì các biểu thức được chỉ định cho ba phần có thể là gần như mọi thứ, vì vậy điều này có độ linh hoạt hơn một chút so với dạng phạm vi số đơn giản hơn được hiển thị ở trên. Các vòng lặp list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này cũng được giới thiệu trong các ngôn ngữ C ++, Java, PHP và Perl.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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 có giá trị của đối tượng tiếp theo trong for [i = 1; i ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này được cho là tổng quát và trừu tượng nhất. Perl và PHP cũng hỗ trợ loại vòng lặp này, nhưng nó được giới thiệu bởi từ khóa for [i = 1; i ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0.Vòng lặp Python list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
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ừ
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 một cách chi tiết. Nhưng bây giờ, hãy để bắt đầu với một nguyên mẫu và ví dụ nhanh chóng, chỉ để làm quen.Vòng lặp Python từ
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 trông như thế này:for in :
for [i = 1; i >> a = ['foo', 'bar', 'baz']
>>> for i in a:
... print[i]
...
foo
bar
baz
Trong ví dụ này,
for [i = 1; i ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7. Mỗi lần thông qua vòng lặp, list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 đảm nhận một mục liên tiếp trong for i in
3, do đó for i in
8 hiển thị các giá trị for i in
9, for in :
0 và for in :
1, tương ứng. Một vòng lặp list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 như thế này là cách pythonic để xử lý các vật phẩm trong một điều khác.Nhưng chính xác thì một điều gì đó là gì? Trước khi kiểm tra
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 vòng lặp xa hơn, sẽ có lợi khi đi sâu hơn vào những gì lặp đi lặp lại trong Python.Vòng lặp
Trong Python, có nghĩa là một đối tượng có thể được sử dụng trong lặp. Thuật ngữ này được sử dụng như:iterable means an object can be used in iteration. The term is used as:
- Một tính từ: Một đối tượng có thể được mô tả là có thể lặp lại. An object may be described as iterable.
- Một danh từ: Một đối tượng có thể được đặc trưng như một điều khác. An object may be characterized as an iterable.
Nếu một đối tượng có thể sử dụng được, nó có thể được chuyển đến chức năng Python tích hợp
for in :
4, trả về một thứ gọi là tererator. Vâng, thuật ngữ có một chút lặp đi lặp lại. Treo ở đó. Tất cả cuối cùng làm việc.iterator. Yes, the terminology gets a bit repetitive. Hang in there. It all works out in the end.Mỗi đối tượng trong ví dụ sau là có thể lặp lại và trả về một số loại lặp khi được chuyển đến
for in :
4:>>>
[number..100].step[10].each {|n| puts n}
0Trong ví dụ này,
for [i = 1; i ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7. Mỗi lần thông qua vòng lặp, list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 đảm nhận một mục liên tiếp trong for i in
3, do đó for i in
8 hiển thị các giá trị for i in
9, for in :
0 và for in :
1, tương ứng. Một vòng lặp list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 như thế này là cách pythonic để xử lý các vật phẩm trong một điều khác.>>>
[number..100].step[10].each {|n| puts n}
1Trong ví dụ này,
for [i = 1; i ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7. Mỗi lần thông qua vòng lặp, list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 đảm nhận một mục liên tiếp trong for i in
3, do đó for i in
8 hiển thị các giá trị for i in
9, for in :
0 và for in :
1, tương ứng. Một vòng lặp list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 như thế này là cách pythonic để xử lý các vật phẩm trong một điều khác.Nhưng chính xác thì một điều gì đó là gì? Trước khi kiểm tra
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 vòng lặp xa hơn, sẽ có lợi khi đi sâu hơn vào những gì lặp đi lặp lại trong Python.Vòng lặp
Trong Python, có nghĩa là một đối tượng có thể được sử dụng trong lặp. Thuật ngữ này được sử dụng như:
Một tính từ: Một đối tượng có thể được mô tả là có thể lặp lại.
Một danh từ: Một đối tượng có thể được đặc trưng như một điều khác.
Nếu một đối tượng có thể sử dụng được, nó có thể được chuyển đến chức năng Python tích hợp
for in :
4, trả về một thứ gọi là tererator. Vâng, thuật ngữ có một chút lặp đi lặp lại. Treo ở đó. Tất cả cuối cùng làm việc.>>>
[number..100].step[10].each {|n| puts n}
2Trong ví dụ này,
for [i = 1; i ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7. Mỗi lần thông qua vòng lặp, list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 đảm nhận một mục liên tiếp trong for i in
3, do đó for i in
8 hiển thị các giá trị for i in
9, for in :
0 và for in :
1, tương ứng. Một vòng lặp list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 như thế này là cách pythonic để xử lý các vật phẩm trong một điều khác.Nhưng chính xác thì một điều gì đó là gì? Trước khi kiểm tra
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 vòng lặp xa hơn, sẽ có lợi khi đi sâu hơn vào những gì lặp đi lặp lại trong Python.Vòng lặp
>>>
[number..100].step[10].each {|n| puts n}
3Trong ví dụ này,
for [i = 1; i ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7. Mỗi lần thông qua vòng lặp, list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 đảm nhận một mục liên tiếp trong for i in
3, do đó for i in
8 hiển thị các giá trị for i in
9, for in :
0 và for in :
1, tương ứng. Một vòng lặp list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 như thế này là cách pythonic để xử lý các vật phẩm trong một điều khác.Nhưng chính xác thì một điều gì đó là gì? Trước khi kiểm tra
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 vòng lặp xa hơn, sẽ có lợi khi đi sâu hơn vào những gì lặp đi lặp lại trong Python.>>>
[number..100].step[10].each {|n| puts n}
4Trong ví dụ này,
for [i = 1; i ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7. Mỗi lần thông qua vòng lặp, list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 đảm nhận một mục liên tiếp trong for i in
3, do đó for i in
8 hiển thị các giá trị for i in
9, for in :
0 và for in :
1, tương ứng. Một vòng lặp list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 như thế này là cách pythonic để xử lý các vật phẩm trong một điều khác.Nhưng chính xác thì một điều gì đó là gì? Trước khi kiểm tra
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 vòng lặp xa hơn, sẽ có lợi khi đi sâu hơn vào những gì lặp đi lặp lại trong Python.>>>
[number..100].step[10].each {|n| puts n}
5Vòng lặp
>>>
[number..100].step[10].each {|n| puts n}
6Trong Python, có nghĩa là một đối tượng có thể được sử dụng trong lặp. Thuật ngữ này được sử dụng như:
Một tính từ: Một đối tượng có thể được mô tả là có thể lặp lại.
Trên thực tế, có thể tạo một iterator trong Python trả về một loạt các đối tượng vô tận sử dụng các chức năng của máy phát và
[number..100].step[10].each {|n| puts n}
07. Nếu bạn cố gắng lấy tất cả các giá trị cùng một lúc từ một trình lặp vô tận, chương trình sẽ bị treo.Các ruột của vòng lặp Python list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
Bây giờ bạn đã được giới thiệu với tất cả các khái niệm bạn cần để hiểu đầy đủ về cách thức hoạt động của vòng lặp Python. Trước khi tiến hành, hãy để xem xét các điều khoản có liên quan:
Lặp đi lặp lại | Quá trình lặp qua các đối tượng hoặc vật phẩm trong bộ sưu tập |
Có thể lặp lại | Một đối tượng [hoặc tính từ được sử dụng để mô tả một đối tượng] có thể được lặp lại |
Người lặp lại | Đối tượng tạo ra các mục hoặc giá trị liên tiếp từ nó có thể liên kết |
4
| Chức năng tích hợp được sử dụng để có được một iterator từ một điều đáng tin cậy |
Bây giờ, hãy xem xét lại vòng lặp
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 đơn giản được trình bày khi bắt đầu hướng dẫn này:>>>
>>> a = ['foo', 'bar', 'baz']
>>> for i in a:
... print[i]
...
foo
bar
baz
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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này mô tả, Python làm như sau:- Gọi
4 để có được trình lặp lại chofor in :
3for i in
- Gọi
7 liên tục để lần lượt lấy từng mục từ trình lặp lạifor in :
- Chấm dứt vòng lặp khi
7 tăng ngoại lệfor in :
6>>> a = ['foo', 'bar', 'baz'] >>> for i in a: ... print[i] ... foo bar baz
Cơ thể vòng lặp được thực hiện một lần cho mỗi mục
for in :
7 trả về, với biến vòng list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
7 được đặt thành mục đã cho cho mỗi lần lặp.Trình tự các sự kiện này được tóm tắt trong sơ đồ sau:
Có lẽ điều này có vẻ như rất nhiều hoạt động kinh doanh khỉ không cần thiết, nhưng lợi ích là đáng kể. Python xử lý lặp lại tất cả các vòng lặp theo cách chính xác theo cách này, và trong Python, Iterables và Iterators rất nhiều:
Nhiều đối tượng tích hợp và thư viện là có thể sử dụng được.
Có một mô -đun thư viện tiêu chuẩn gọi là
07 chứa nhiều chức năng trả về Iterables.[number..100].step[10].each {|n| puts n}
Có thể tạo ra các đối tượng do người dùng xác định với khả năng hướng đối tượng Python có thể được thực hiện để có thể sử dụng được.
Python có tính năng cấu trúc gọi là trình tạo cho phép bạn tạo trình lặp của riêng mình một cách đơn giản, đơn giản.
Bạn sẽ khám phá thêm về tất cả những điều trên trong suốt loạt bài này. Tất cả chúng có thể là mục tiêu của vòng lặp
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 và cú pháp giống nhau trên bảng. Nó thanh lịch trong sự đơn giản và linh hoạt.Lặp lại thông qua một từ điển
Bạn đã thấy trước đó rằng một trình lặp có thể được lấy từ một từ điển với
for in :
4, vì vậy bạn biết từ điển phải có thể sử dụng được. Điều gì xảy ra khi bạn lặp qua một từ điển? Hãy xem nào:>>>
[number..100].step[10].each {|n| puts n}
8Vò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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này mô tả, Python làm như sau:Gọi
for in :
4 để có được trình lặp lại cho for i in
3>>>
[number..100].step[10].each {|n| puts n}
9Vò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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này mô tả, Python làm như sau:>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
0Vò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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này mô tả, Python làm như sau:>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này mô tả, Python làm như sau:>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này mô tả, Python làm như sau:>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
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 list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này mô tả, Python làm như sau:
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
Gọi
for in :
4 để có được trình lặp lại cho for i in
3Gọi
for in :
7 liên tục để lần lượt lấy từng mục từ trình lặp lại>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này mô tả, Python làm như sau:Gọi
for in :
4 để có được trình lặp lại cho for i in
3Gọi
for in :
7 liên tục để lần lượt lấy từng mục từ trình lặp lại>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
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
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 này mô tả, Python làm như sau:>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
6Bạn cũng có thể lấy tất cả các giá trị cùng một lúc với
[number..100].step[10].each {|n| puts n}
00 hoặc [number..100].step[10].each {|n| puts n}
02. 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ì:>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
7Tuy nhiên, khi
[number..100].step[10].each {|n| puts n}
27 đượ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 [number..100].step[10].each {|n| puts n}
00 hoặc [number..100].step[10].each {|n| puts n}
02 theo cách này. Giống như trình lặp, các đối tượng [number..100].step[10].each {|n| puts n}
37 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 [number..100].step[10].each {|n| puts n}
00 hoặc [number..100].step[10].each {|n| puts n}
02 trên đối tượng [number..100].step[10].each {|n| puts n}
37 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ớ.[number..100].step[10].each {|n| puts n}
49 trả về một số lượng có thể mang lại số nguyên bắt đầu bằng [number..100].step[10].each {|n| puts n}
50, cho đến nhưng không bao gồm [number..100].step[10].each {|n| puts n}
35. Nếu được chỉ định, [number..100].step[10].each {|n| puts n}
52 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]:>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
8Nếu
[number..100].step[10].each {|n| puts n}
52 bị bỏ qua, nó mặc định là list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
8:>>>
# loop vs. iterator
i = 0 5.times do
while i < 5
puts "hello" puts "hello"
i += 1
end end
9Tất cả các tham số được chỉ định cho
[number..100].step[10].each {|n| puts n}
27 phải là số nguyên, nhưng bất kỳ tham số nào có thể âm. Đương nhiên, nếu [number..100].step[10].each {|n| puts n}
50 lớn hơn [number..100].step[10].each {|n| puts n}
35, [number..100].step[10].each {|n| puts n}
52 phải âm [nếu bạn muốn có bất kỳ kết quả nào]:>>>
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
0Thay đổi hành vi vòng lặp list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
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
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
9 có thể bị gián đoạn với các câu lệnh [number..100].step[10].each {|n| puts n}
61 và [number..100].step[10].each {|n| puts n}
62 và được sửa đổi bằng mệnh đề [number..100].step[10].each {|n| puts n}
63. Những khả năng này cũng có sẵn với vòng lặp list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0.Các câu lệnh [number..100].step[10].each {|n| puts n}
61 và [number..100].step[10].each {|n| puts n}
62
[number..100].step[10].each {|n| puts n}
[number..100].step[10].each {|n| puts n}
[number..100].step[10].each {|n| puts n}
61 và [number..100].step[10].each {|n| puts n}
62 hoạt động theo cùng một cách với các vòng list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 như với words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
9 vòng lặp. [number..100].step[10].each {|n| puts n}
61 chấm dứt hoàn toàn vòng lặp và tiến hành câu lệnh đầu tiên sau vòng lặp:>>>
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
1[number..100].step[10].each {|n| puts n}
62 chấm dứt lần lặp hiện tại và tiến hành lần lặp tiếp theo:
>>>
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
2Điều khoản [number..100].step[10].each {|n| puts n}
63
[number..100].step[10].each {|n| puts n}
Một vòng lặp
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0 cũng có thể có mệnh đề [number..100].step[10].each {|n| puts n}
63. Việc giải thích tương tự như vòng lặp words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
9. Điều khoản [number..100].step[10].each {|n| puts n}
63 sẽ được thực thi nếu vòng lặp chấm dứt thông qua sự kiệt sức của điều đó:>>>
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
3Điều khoản
[number..100].step[10].each {|n| puts n}
63 won won được thực thi nếu danh sách bị phá vỡ bằng tuyên bố [number..100].step[10].each {|n| puts n}
61:>>>
words = ["one", "two", "three", "four"]
# loop vs. iterator
i = 0 words.each do |w|
while i < words.length
puts words[i] puts w
i += 1
end end
4Sự kết luận
Hướng dẫn này đã trình bày vòng lặp
list = "a b c d e f g h i j".split[" "]
# => ['a','b','c','d','e','f','g','h','i','j']
list.each_slice[3] do |group|
puts group.join ""
end
# prints abc, def, ghi, j
0, công việc của sự lặp lại xác định trong Python.definite iteration in Python.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]