Có câu lệnh lặp nào trong Python không?

Luồng của các chương trình được viết bằng bất kỳ ngôn ngữ lập trình nào là tuần tự theo mặc định. Câu lệnh đầu tiên trong một hàm được thực thi trước, tiếp theo là câu lệnh thứ hai, v.v. Có thể xảy ra tình huống khi lập trình viên cần thực thi một khối mã nhiều lần. Với mục đích này, các ngôn ngữ lập trình cung cấp nhiều loại vòng lặp khác nhau có thể lặp lại một số mã cụ thể nhiều lần. Ở đây, chúng ta sẽ nói về các câu lệnh lặp trong Python

Trong một ngôn ngữ lập trình, một câu lệnh lặp chứa các lệnh liên tục lặp lại cho đến khi đạt được một điều kiện nhất định. Đọc để tìm hiểu thêm về họ

Mục lục

• Các câu lệnh lặp trong Python
• cho vòng lặp
• Trong khi lặp lại
• Vòng lặp lồng nhau

Các câu lệnh lặp trong Python

Vòng lặp đơn giản hóa các vấn đề phức tạp thành những vấn đề trơn tru. Nó cho phép các lập trình viên sửa đổi dòng chảy của chương trình để thay vì viết đi viết lại cùng một đoạn mã, các lập trình viên có thể lặp lại đoạn mã đó một số lần hữu hạn

Trong Python, có ba loại vòng lặp khác nhau. vòng lặp for, vòng lặp while và vòng lặp lồng nhau
Ở đây, chúng ta sẽ đọc về các loại vòng lặp khác nhau này và cách sử dụng chúng

cho vòng lặp

Vòng lặp for được sử dụng trong trường hợp lập trình viên cần thực thi một phần mã lệnh cho đến khi thỏa mãn điều kiện cho trước. Vòng lặp for còn được gọi là vòng lặp kiểm tra trước. Tốt nhất là sử dụng vòng lặp for nếu biết trước số lần lặp

Trong Python, không có kiểu C cho vòng lặp, tôi. e. , cho [i=0; i 5 print[odds[3]] IndexError: list index out of range

Đây là một cách tiếp cận tốt hơn. một

odds = [1, 3, 5, 7]
for num in odds:
    print[num]

1
3
5
7

Cái này ngắn hơn — chắc chắn là ngắn hơn cái gì đó in mọi số trong danh sách hàng trăm số — và cũng mạnh mẽ hơn

odds = [1, 3, 5, 7, 9, 11]
for num in odds:
    print[num]

1
3
5
7
9
11

Phiên bản cải tiến sử dụng a để lặp lại một thao tác — trong trường hợp này là in — một lần cho mỗi thứ trong một trình tự. Hình thức chung của một vòng lặp là

print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

0

Sử dụng ví dụ về tỷ lệ cược ở trên, vòng lặp có thể trông như thế này

trong đó mỗi số [_______9_______7] trong biến

odds = [1, 3, 5]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

4 được lặp và in hết số này đến số khác. Các số khác trong sơ đồ biểu thị số được in trong chu kỳ vòng lặp nào [1 là chu kỳ vòng lặp đầu tiên và 6 là chu kỳ vòng lặp cuối cùng]

Chúng ta có thể gọi bất cứ thứ gì chúng ta thích, nhưng phải có dấu hai chấm ở cuối dòng bắt đầu vòng lặp và chúng ta phải thụt lề bất cứ thứ gì chúng ta muốn chạy bên trong vòng lặp. Không giống như nhiều ngôn ngữ khác, không có lệnh nào biểu thị phần cuối của thân vòng lặp [e. g.

odds = [1, 3, 5]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

9];

Những gì trong một cái tên?

Trong ví dụ trên, biến vòng lặp được đặt tên là

odds = [1, 3, 5]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

7 để ghi nhớ; . Chúng tôi có thể chọn bất kỳ tên nào chúng tôi muốn cho các biến. Chúng ta có thể dễ dàng chọn tên

1
3
5

2 cho biến vòng lặp, miễn là chúng ta sử dụng cùng một tên khi gọi biến bên trong vòng lặp

print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

1

1
3
5
7
9
11

Bạn nên chọn tên biến có ý nghĩa, nếu không sẽ khó hiểu vòng lặp đang làm gì hơn

Đây là một vòng lặp khác liên tục cập nhật một biến

print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

3

print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

4

Thật đáng để theo dõi từng bước thực hiện chương trình nhỏ này. Vì có ba tên trong

1
3
5

3 nên câu lệnh ở dòng 4 sẽ được thực hiện ba lần. Khoảng thời gian đầu tiên,

1
3
5

4 bằng 0 [giá trị được gán cho nó ở dòng 1] và

1
3
5

5 là

1
3
5

6. Câu lệnh thêm 1 vào giá trị cũ của

1
3
5

4, tạo ra 1 và cập nhật

1
3
5

4 để chỉ giá trị mới đó. Khoảng thời gian tiếp theo,

1
3
5

5 là

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      3 print[odds[1]]
      4 print[odds[2]]
----> 5 print[odds[3]]

IndexError: list index out of range

0 và

1
3
5

4 là 1, vì vậy

1
3
5

4 được cập nhật thành 2. Sau một lần cập nhật nữa,

1
3
5

4 là 3;

Lưu ý rằng một biến vòng lặp là một biến đang được sử dụng để ghi lại tiến trình trong một vòng lặp. Nó vẫn tồn tại sau khi vòng lặp kết thúc và chúng ta cũng có thể sử dụng lại các biến được xác định trước đó là biến vòng lặp

print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

5

print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

6

Cũng lưu ý rằng việc tìm độ dài của một đối tượng là một hoạt động phổ biến đến mức Python thực sự có một chức năng tích hợp để thực hiện nó được gọi là

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      3 print[odds[1]]
      4 print[odds[2]]
----> 5 print[odds[3]]

IndexError: list index out of range

6

print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

7

print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

8

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      3 print[odds[1]]
      4 print[odds[2]]
----> 5 print[odds[3]]

IndexError: list index out of range

6 nhanh hơn nhiều so với bất kỳ hàm nào chúng ta có thể tự viết và dễ đọc hơn nhiều so với vòng lặp hai dòng;

Từ 1 đến N

Python có một hàm tích hợp có tên là

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      3 print[odds[1]]
      4 print[odds[2]]
----> 5 print[odds[3]]

IndexError: list index out of range

8 tạo ra một chuỗi số.

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      3 print[odds[1]]
      4 print[odds[2]]
----> 5 print[odds[3]]

IndexError: list index out of range

8 có thể chấp nhận 1, 2 hoặc 3 thông số

• Nếu một tham số được đưa ra,

  ---------------------------------------------------------------------------
  IndexError                                Traceback [most recent call last]
   in []
        3 print[odds[1]]
        4 print[odds[2]]
  ----> 5 print[odds[3]]
  
  IndexError: list index out of range
  

  8 sẽ tạo ra một chuỗi có độ dài đó, bắt đầu từ 0 và tăng dần 1. Ví dụ:

  odds = [1, 3, 5, 7]
  for num in odds:
      print[num]
  

  1 tạo ra các số

  odds = [1, 3, 5, 7]
  for num in odds:
      print[num]
  

  2
• Nếu có hai tham số,

  ---------------------------------------------------------------------------
  IndexError                                Traceback [most recent call last]
   in []
        3 print[odds[1]]
        4 print[odds[2]]
  ----> 5 print[odds[3]]
  
  IndexError: list index out of range
  

  8 bắt đầu ở tham số đầu tiên và kết thúc ngay trước tham số thứ hai, tăng thêm một. Ví dụ:

  odds = [1, 3, 5, 7]
  for num in odds:
      print[num]
  

  4 tạo ra

  odds = [1, 3, 5, 7]
  for num in odds:
      print[num]
  

  5
• Nếu

  ---------------------------------------------------------------------------
  IndexError                                Traceback [most recent call last]
   in []
        3 print[odds[1]]
        4 print[odds[2]]
  ----> 5 print[odds[3]]
  
  IndexError: list index out of range
  

  8 được cung cấp 3 tham số, nó sẽ bắt đầu ở tham số đầu tiên, kết thúc ngay trước tham số thứ hai và tăng dần theo tham số thứ ba. Ví dụ:

  odds = [1, 3, 5, 7]
  for num in odds:
      print[num]
  

  7 tạo ra

  odds = [1, 3, 5, 7]
  for num in odds:
      print[num]
  

  8

Sử dụng

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      3 print[odds[1]]
      4 print[odds[2]]
----> 5 print[odds[3]]

IndexError: list index out of range

8, viết một vòng lặp sử dụng

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      3 print[odds[1]]
      4 print[odds[2]]
----> 5 print[odds[3]]

IndexError: list index out of range

8 để in ra 3 số tự nhiên đầu tiên

print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]

9

Giải pháp

1
3
5
7

0

Hiểu các vòng lặp

Cho vòng lặp sau

1
3
5
7

1

Phần thân của vòng lặp được thực hiện bao nhiêu lần?

• 3 lần
• 4 lần
• 5 lần
• 6 lần

Giải pháp

Phần thân của vòng lặp được thực hiện 6 lần

Sức mạnh tính toán với vòng lặp

Lũy thừa được tích hợp vào Python

1
3
5
7

2

1
3
5
7

3

Viết một vòng lặp tính toán kết quả tương tự như

1
3
5
7

1 sử dụng phép nhân [và không có lũy thừa]

Giải pháp

1
3
5
7

4

Tổng hợp một danh sách

Viết một vòng lặp tính tổng các phần tử trong một danh sách bằng cách cộng từng phần tử và in ra giá trị cuối cùng, do đó,

1
3
5
7

2 in ra 562

Giải pháp

1
3
5
7

5

Tính giá trị của một đa thức

Hàm dựng sẵn

1
3
5
7

3 nhận một chuỗi [e. g. một danh sách] và tạo một chuỗi mới có cùng độ dài. Mỗi phần tử của dãy mới là một cặp bao gồm chỉ số [0, 1, 2,…] và giá trị từ dãy ban đầu

1
3
5
7

6

Đoạn mã trên lặp qua

1
3
5
7

4, gán chỉ số cho

1
3
5
7

5 và giá trị cho

1
3
5
7

6

Giả sử bạn đã mã hóa một đa thức thành một danh sách các hệ số theo cách sau. phần tử đầu tiên là số hạng không đổi, phần tử thứ hai là hệ số của số hạng tuyến tính, phần tử thứ ba là hệ số của số hạng bậc hai, v.v.

1
3
5
7

7

1
3
5
7

8

Viết một vòng lặp sử dụng

1
3
5
7

7 để tính giá trị

1
3
5
7

8 của bất kỳ đa thức nào, cho trước

1
3
5
7

9 và

odds = [1, 3, 5, 7, 9, 11]
for num in odds:
    print[num]

0

Có lệnh lặp lại trong Python không?

repeat[] Mô-đun itertools cung cấp hàm repeat[] để thực hành lặp lại trong Python . Trong repeat[], chúng tôi cung cấp dữ liệu cũng như số lần dữ liệu sẽ được lặp lại.

Câu lệnh lặp trong Python là gì?

Các câu lệnh lặp được gọi là vòng lặp và được sử dụng để lặp lại cùng một mã nhiều lần liên tiếp . Python có hai loại vòng lặp. Kiểm soát theo điều kiện và Kiểm soát theo số lượng. Vòng lặp điều khiển theo điều kiện sử dụng một điều kiện đúng/sai để kiểm soát số lần nó lặp lại - trong khi.