Hướng dẫn why use iterator instead of for loop python - tại sao lại sử dụng trình lặp thay vì for loop 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

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

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

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 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

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

for i = 1 to 10
    <loop body>

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

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

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

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

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

for (i = 1; i <= 10; i++)
    <loop body>

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

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

for i in <collection>
    <loop body>

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

for (i = 1; i <= 10; i++)
    <loop body>

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

for (i = 1; i <= 10; i++)
    <loop body>

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

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, j0

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

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

for <var> in <iterable>:
    <statement(s)>

for (i = 1; i <= 10; i++)
    <loop body>

for (i = 1; i <= 10; i++)
    <loop body>

for (i = 1; i <= 10; i++)
    <loop body>

for i in <collection>
    <loop body>

for (i = 1; i <= 10; i++)
    <loop body>

Đây là một ví dụ đại diện:

>>>

>>> a = ['foo', 'bar', 'baz']
>>> for i in a:
...     print(i)
...
foo
bar
baz

Trong ví dụ này,

for (i = 1; i <= 10; i++)
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

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

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

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for <var> in <iterable>:
    <statement(s)>

for <var> in <iterable>:
    <statement(s)>

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

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

for <var> in <iterable>:
    <statement(s)>

for <var> in <iterable>:
    <statement(s)>

(number..100).step(10).each {|n| puts n}

for (i = 1; i <= 10; i++)
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

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

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

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for <var> in <iterable>:
    <statement(s)>

for <var> in <iterable>:
    <statement(s)>

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

(number..100).step(10).each {|n| puts n}

for (i = 1; i <= 10; i++)
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

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

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

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for <var> in <iterable>:
    <statement(s)>

for <var> in <iterable>:
    <statement(s)>

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

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

for <var> in <iterable>:
    <statement(s)>

(number..100).step(10).each {|n| puts n}

for (i = 1; i <= 10; i++)
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

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

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

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for <var> in <iterable>:
    <statement(s)>

for <var> in <iterable>:
    <statement(s)>

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

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

(number..100).step(10).each {|n| puts n}

for (i = 1; i <= 10; i++)
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

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

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

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for <var> in <iterable>:
    <statement(s)>

for <var> in <iterable>:
    <statement(s)>

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

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

(number..100).step(10).each {|n| puts n}

for (i = 1; i <= 10; i++)
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

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

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

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for i in <collection>
    <loop body>

for <var> in <iterable>:
    <statement(s)>

for <var> in <iterable>:
    <statement(s)>

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

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

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

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, j0

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:

for <var> in <iterable>:
    <statement(s)>

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

>>>

>>> 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

• Gọi

  for <var> in <iterable>:
      <statement(s)>
  

  4 để có được trình lặp lại cho

  for i in <collection>
      <loop body>
  

  3
• Gọi

  for <var> in <iterable>:
      <statement(s)>
  

  7 liên tục để lần lượt lấy từng mục từ trình lặp lại
• Chấm dứt vòng lặp khi

  for <var> in <iterable>:
      <statement(s)>
  

  7 tăng ngoại lệ

  >>> a = ['foo', 'bar', 'baz']
  >>> for i in a:
  ...     print(i)
  ...
  foo
  bar
  baz
  

  6

Cơ thể vòng lặp được thực hiện một lần cho mỗi mục

for <var> in <iterable>:
    <statement(s)>

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

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à

  (number..100).step(10).each {|n| puts n}

  07 chứa nhiều chức năng trả về Iterables.

• 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

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 <var> in <iterable>:
    <statement(s)>

>>>

(number..100).step(10).each {|n| puts n}

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

Gọi

for <var> in <iterable>:
    <statement(s)>

for i in <collection>
    <loop body>

>>>

(number..100).step(10).each {|n| puts n}

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

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

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

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

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

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

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

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

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, j0 này mô tả, Python làm như sau:

Gọi

for <var> in <iterable>:
    <statement(s)>

for i in <collection>
    <loop body>

Gọi

for <var> in <iterable>:
    <statement(s)>

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

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

Gọi

for <var> in <iterable>:
    <statement(s)>

for i in <collection>
    <loop body>

Gọi

for <var> in <iterable>:
    <statement(s)>

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

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

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

Bạ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}

(number..100).step(10).each {|n| puts n}

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

Tuy nhiên, khi

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

Nếu

(number..100).step(10).each {|n| puts 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

>>>

# loop               vs.           iterator

i = 0                              5.times do
while i < 5                         
  puts "hello"                       puts "hello"
  i += 1
end                                end

Tất cả các tham số được chỉ định cho

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

>>>

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

Thay đổ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, j0

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

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts 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

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts 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

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

(number..100).step(10).each {|n| puts n}

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

(number..100).step(10).each {|n| puts n}

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

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

(number..100).step(10).each {|n| puts n}

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

(number..100).step(10).each {|n| puts n}

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

(number..100).step(10).each {|n| puts n}

(number..100).step(10).each {|n| puts n}

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

Sự 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

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.