Một số chương trình chúng tôi đã thấy cho đến nay hơi khó gõ. Nếu chúng ta muốn tạo một mẫu lặp đi lặp lại trong bản vẽ của mình, thì có thể mất nhiều dòng mã. Rất may, Python có một số cách để thực hiện loại nhiệm vụ này dễ dàng hơn. Hiện tại, bạn sẽ có bản xem trước ngắn gọn về cấu trúc và chức năng điều khiển hữu ích trong Python mà bạn sẽ tìm hiểu sau
Cấu trúc điều khiển được gọi là vòng lặp for. Nếu bạn đã học các ngôn ngữ lập trình khác thì bạn có thể quen với những gì nó làm nhưng cấu trúc có thể mới. Vòng lặp for cho phép Python thực thi chương trình theo kiểu phi tuyến tính. Thay vì đánh giá từng dòng mã cho đến khi kết thúc, khi chương trình đạt đến vòng lặp for, nó sẽ yêu cầu chương trình thực hiện lặp đi lặp lại một tập hợp các dòng. Sau khi thực hiện tất cả những điều đó, chương trình sẽ tiếp tục đánh giá và thực thi bất cứ điều gì bên dưới vòng lặp for
Trong đoạn mã dưới đây, chúng tôi sử dụng hàm range để chỉ định số lần mã bên trong vòng lặp for sẽ thực thi. Trong chương sau, chúng ta sẽ giải thích chính xác hàm phạm vi đang làm gì và nó hoạt động như thế nào với vòng lặp for. Hiện tại, chỉ cần cố gắng hiểu điều gì sẽ xảy ra khi đoạn mã sau thực thi
Có một vài điều cần chú ý ở đây khi bạn sử dụng nó sau này. Thứ nhất, hai câu lệnh in ở dòng 4 và 5 được thực hiện ba lần, nhưng chúng ta không in dòng 4 ba lần rồi in ba lần dòng 5. Thay vào đó, chúng tôi in dòng 4, rồi dòng 5. Khi đã xong, vòng lặp for sẽ lặp lại hoặc đưa chương trình trở lại điểm bắt đầu của vòng lặp for và tiếp tục in lại dòng 4 và 5 cho đến khi nó in cả hai dòng tổng cộng ba lần
Thứ hai, những dòng này được in cùng số lần như bên trong hàm range. Nếu chúng tôi muốn in chúng nhiều lần hoặc ít hơn, thì chúng tôi chỉ cần thay đổi số bên trong dấu ngoặc đơn trên dòng 3
Cuối cùng, vết lõm rất quan trọng ở đây. Tất cả các câu lệnh được in ra nhiều lần đều được thụt vào bên dưới vòng lặp for. Khi chúng tôi ngừng thụt lề những dòng đó, thì chương trình nằm ngoài vòng lặp for và nó sẽ tiếp tục thực thi tuyến tính. Nếu bạn muốn xem quá trình thực thi, hãy kiểm tra mã ở trên trong codelens
Bây giờ là lúc kết hợp điều này với mô-đun Rùa. Chúng ta có thể làm được rất nhiều thứ hay ho nếu kết hợp được hai điều này. Dưới đây là mã để làm điều đó. Cố gắng dự đoán những gì chương trình sẽ làm trước khi chạy nó
Trong phần về trực quan hóa dữ liệu, chúng tôi đã viết mã Python để vẽ các giá trị quan tâm từ bộ dữ liệu về tình trạng viêm nhiễm đầu tiên của chúng tôi [
odds = [1, 3, 5]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
Chúng tôi có hàng tá bộ dữ liệu ngay bây giờ và có khả năng nhiều hơn nữa nếu Dr. Maverick có thể duy trì tốc độ thử nghiệm lâm sàng nhanh đáng ngạc nhiên. Chúng tôi muốn tạo các biểu đồ cho tất cả các tập dữ liệu của mình bằng một câu lệnh. Để làm được điều đó, chúng ta sẽ phải dạy máy tính cách lặp lại mọi thứ
Một tác vụ ví dụ mà chúng tôi có thể muốn lặp lại là truy cập các số trong danh sách, chúng tôi sẽ thực hiện thao tác này bằng cách in từng số trên một dòng của chính nó
odds = [1, 3, 5, 7]
Trong Python, một danh sách về cơ bản là một tập hợp các phần tử được sắp xếp theo thứ tự và mỗi phần tử có một số duy nhất được liên kết với nó - chỉ mục của nó. Điều này có nghĩa là chúng ta có thể truy cập các phần tử trong danh sách bằng chỉ số của chúng. Ví dụ: chúng ta có thể lấy số đầu tiên trong danh sách
odds = [1, 3, 5]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
odds = [1, 3, 5]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
odds = [1, 3, 5]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
1
3
5
7
Đây là một cách tiếp cận tồi vì ba lý do
không thể mở rộng. Hãy tưởng tượng bạn cần in một danh sách có hàng trăm phần tử. Có thể dễ dàng hơn để nhập chúng theo cách thủ công
Khó bảo trì. Nếu chúng ta muốn trang trí mỗi phần tử được in bằng dấu hoa thị hoặc bất kỳ ký tự nào khác, chúng ta sẽ phải thay đổi bốn dòng mã. Mặc dù đây có thể không phải là vấn đề đối với danh sách nhỏ, nhưng nó chắc chắn sẽ là vấn đề đối với danh sách dài hơn
Dễ vỡ. Nếu chúng ta sử dụng nó với một danh sách có nhiều phần tử hơn những gì chúng ta hình dung ban đầu, nó sẽ chỉ hiển thị một phần các phần tử của danh sách. Mặt khác, một danh sách ngắn hơn sẽ gây ra lỗi vì nó sẽ cố gắng hiển thị các phần tử của danh sách không tồn tại
odds = [1, 3, 5]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
________số 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
Đâ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]]
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ố [_______0_______7] trong biến
odds = [1, 3, 5]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
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]]
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à
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ênodds = [1, 3, 5] print[odds[0]] print[odds[1]] print[odds[2]] print[odds[3]]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ặp1 3 51print[odds[0]] print[odds[1]] print[odds[2]] print[odds[3]]1 3 5 7 9 11Bạ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]]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
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
1
3
5
1
3
5
1
3
5
1
3
5
1
3
5
1
3
5
---------------------------------------------------------------------------
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
1
3
5
1
3
5
1
3
5
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]]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
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
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
print[odds[0]]
print[odds[1]]
print[odds[2]]
print[odds[3]]
---------------------------------------------------------------------------
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
Từ 1 đến N
Python có một hàm tích hợp có tên là
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 range8 có thể chấp nhận 1, 2 hoặc 3 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
- Nếu một tham số được đưa ra,
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ụ:--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[odds[1]] 4 print[odds[2]] ----> 5 print[odds[3]] IndexError: list index out of range1 tạo ra các sốodds = [1, 3, 5, 7] for num in odds: print[num]2odds = [1, 3, 5, 7] for num in odds: print[num]- Nếu hai tham số được đưa ra,
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ụ:--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[odds[1]] 4 print[odds[2]] ----> 5 print[odds[3]] IndexError: list index out of range4 tạo raodds = [1, 3, 5, 7] for num in odds: print[num]5odds = [1, 3, 5, 7] for num in odds: print[num]- Nếu
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ụ:--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[odds[1]] 4 print[odds[2]] ----> 5 print[odds[3]] IndexError: list index out of range7 tạo raodds = [1, 3, 5, 7] for num in odds: print[num]8odds = [1, 3, 5, 7] for num in odds: print[num]Sử dụng
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 range8 để in ra 3 số tự nhiên đầu tiên--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[odds[1]] 4 print[odds[2]] ----> 5 print[odds[3]] IndexError: list index out of range9print[odds[0]] print[odds[1]] print[odds[2]] print[odds[3]]Giải pháp
01 3 5 7
Hiểu các vòng lặp
Cho vòng lặp sau
1 3 5 7Phầ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
21 3 5 731 3 5 7Viết một vòng lặp tính toán kết quả tương tự như
1 sử dụng phép nhân [và không có lũy thừa]1 3 5 7Giải pháp
41 3 5 7
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 đó,
2 in ra 5621 3 5 7Giải pháp
51 3 5 7
Tính giá trị của một đa thức
Hàm dựng sẵn
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 đầu1 3 5 761 3 5 7Đoạn mã trên lặp qua
4, gán chỉ số cho1 3 5 75 và giá trị cho1 3 5 761 3 5 7Giả 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.
71 3 5 781 3 5 7Viết một vòng lặp sử dụng
7 để tính giá trị1 3 5 78 của bất kỳ đa thức nào, cho trước1 3 5 79 và1 3 5 70odds = [1, 3, 5, 7, 9, 11] for num in odds: print[num]3 loại vòng lặp trong Python là gì?
Loại vòng lặp .cho vòng lặp. Vòng lặp for trong Python được sử dụng để lặp qua một chuỗi [danh sách, bộ dữ liệu, bộ, từ điển và chuỗi]. Sơ đồ. .Trong khi lặp lại. Vòng lặp while được sử dụng để thực thi một tập hợp các câu lệnh miễn là một điều kiện là đúng. .Vòng lặp lồng nhau. Nếu một vòng lặp tồn tại bên trong phần thân của một vòng lặp khác, nó được gọi là vòng lặp lồng nhauCâu lệnh lặp trong lập trình 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 đoạn mã nhiều lần liên tiếp . Số lần lặp lại dựa trên tiêu chí được xác định trong cấu trúc vòng lặp, thường là biểu thức đúng/sai.