Cách thay đổi giá trị trong vòng lặp for (Python)

Máy tính hiện đại có thể thực hiện hàng triệu hoặc thậm chí hàng tỷ lệnh trong một giây. Với các kỹ thuật được thảo luận cho đến nay, thật khó để có được một chương trình tự chạy trong hơn một phần giây.

Thực tế, chúng ta không thể viết hàng triệu lệnh để máy tính luôn bận. Để giữ cho máy tính thực hiện công việc hữu ích, chúng ta cần lặp đi lặp lại, lặp đi lặp lại cùng một khối mã. Có hai loại câu lệnh Python để làm điều đó. các vòng lặp

1
2
3

8 đơn giản hơn, mà chúng tôi sẽ thực hiện ngay và các vòng lặp

1
2
3

9, mà chúng tôi sẽ thực hiện sau, trong

Hai vòng sơ loại

1. Giá trị của các biến đã được xác định có thể được cập nhật. Điều này sẽ đặc biệt quan trọng trong các vòng lặp. Để chuẩn bị cho điều đó, trước tiên chúng tôi theo dõi cách các biến có thể được cập nhật trong một tình huống thậm chí đơn giản hơn, trong đó các câu lệnh chỉ được thực hiện theo thứ tự văn bản
2. Các loại trình tự được sử dụng trong vòng lặp

   1
   2
   3

   8. Chúng ta sẽ xem xét một loại trình tự cơ bản.

   for count in [1, 2, 3]: 
       print[count] 
       print['Yes' * count] 
   

   1

Sau đó, chúng tôi kết hợp tất cả lại với nhau. Đây là một phần dài. Đi chậm và cẩn thận

1. 13. 1. Cập nhật biến

Các chương trình cho đến nay đã xác định và sử dụng các biến, nhưng khác với các ví dụ shell ban đầu, chúng tôi đã không thay đổi giá trị của các biến hiện có. Bây giờ hãy xem xét một ví dụ đặc biệt đơn giản, vừa được chọn làm minh họa, trong tệp ví dụ

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

2

1
2
3
4
5

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

Bạn có thể dự đoán kết quả? . Đặc biệt nếu bạn không đoán đúng, điều quan trọng là phải hiểu điều gì sẽ xảy ra, từng bước một. Điều đó có nghĩa là theo dõi những thay đổi đối với các biến được thực hiện bởi mỗi câu lệnh

Trong bảng bên dưới, các câu lệnh được gọi bằng các số ghi nhãn các dòng trong mã ở trên. Chúng ta có thể theo dõi trạng thái của từng biến sau khi mỗi dòng được thực thi. Một dấu gạch ngang được hiển thị khi một biến không được xác định. Chẳng hạn, sau khi dòng 1 được thực thi, một giá trị được gán cho x, nhưng y vẫn chưa được xác định. Sau đó, y nhận được một giá trị trong dòng 2. Nhận xét bên phải tóm tắt những gì đang xảy ra. Vì x có giá trị 3 khi dòng 2 bắt đầu, nên x+2 bằng 3+2. Trong dòng thứ ba, chúng tôi sử dụng thực tế là phía bên phải của câu lệnh gán sử dụng các giá trị của biến khi dòng bắt đầu thực thi [phần còn lại sau khi dòng trước của bảng được thực thi], nhưng việc gán cho biến y ở bên trái gây ra . Dòng 4 sau đó thay đổi x, sử dụng giá trị mới nhất của y [10, không phải giá trị ban đầu 5. ]. Kết quả từ dòng 5 xác nhận giá trị của x và y

LinexyComment13- 2355=3+2, sử dụng giá trị của x từ dòng trước331010=2*5 ở bên phải, sử dụng giá trị của y từ dòng trước47107=10-3 ở bên phải, sử dụng giá trị của x và y từ . 7 10

Khi chúng ta tạo một bảng như vậy thì thứ tự thực hiện sẽ luôn là thứ tự của các dòng trong bảng. Trong mã tuần tự đơn giản này, nó cũng tuân theo thứ tự văn bản của chương trình. Theo dõi từng dòng thực hiện của một chương trình theo đúng thứ tự thực hiện, cẩn thận, theo dõi các giá trị hiện tại của các biến, sẽ được gọi là chơi máy tính. Một bảng như trên là một cách có tổ chức để theo dõi

1. 13. 2. Loại

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

1

Danh sách được sắp xếp thứ tự các dữ liệu tùy ý. Danh sách là loại dữ liệu đầu tiên được thảo luận cho đến nay có thể thay đổi. độ dài của chuỗi có thể được thay đổi và các phần tử được thay thế. Chúng tôi sẽ trì hoãn cuộc thảo luận về các thay đổi đối với danh sách cho đến khi giới thiệu thêm về các đối tượng. Danh sách có thể được viết rõ ràng. Đọc các ví dụ sau

________số 8

Định dạng cơ bản là một danh sách dữ liệu tùy ý được đặt trong dấu ngoặc vuông, được phân tách bằng dấu phẩy

1. 13. 3. Hàm

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

4, Phần 1

Có một chức năng tích hợp sẵn

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

4, có thể được sử dụng để tự động tạo các chuỗi số học thông thường. Hãy thử cách sau trong Shell

1
2
3

1

Mô hình chung để sử dụng là

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

6sizeOfSequence____37

Cú pháp này sẽ tạo ra các số nguyên, mỗi lần một số nguyên, khi cần. Nếu bạn muốn xem tất cả kết quả cùng một lúc dưới dạng danh sách, bạn có thể chuyển đổi thành

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

1 như trong ví dụ trên. Dãy kết quả bắt đầu từ 0 và kết thúc trước tham số. Chúng ta sẽ thấy có những lý do chính đáng để bắt đầu từ con số 0 trong Python. Một thuộc tính quan trọng của các chuỗi được tạo bởi

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

9 là tổng số phần tử là

1
2
3

60. Trình tự bỏ qua số

1
2
3

60, nhưng thay vào đó bao gồm 0

Với nhiều tham số hơn, hàm

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

4 có thể được sử dụng để tạo ra nhiều trình tự đa dạng hơn nhiều. Các chi tiết được thảo luận trong và

Trong thuật ngữ máy tính, việc tạo ra các giá trị của một chuỗi chỉ khi cần thiết được gọi là đánh giá lười biếng

1. 13. 4. Vòng lặp

1
2
3

8 cơ bản

Hãy thử cách sau trong Shell. Bạn nhận được một chuỗi các dòng tiếp tục trước khi Shell phản hồi. Sau khi nhìn thấy dấu hai chấm ở cuối dòng đầu tiên, Shell biết các dòng sau sẽ được thụt vào

Đảm bảo nhập một dòng trống khác. [Chỉ cần nhấn

1
2
3

64. ] ở cuối để Shell phản hồi.

1
2
3

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

Đây là một vòng lặp

1
2
3

8. Nó có tiêu đề bắt đầu bằng

1
2
3

8, tiếp theo là tên biến [trong trường hợp này là

1
2
3

67], từ

1
2
3

68, một chuỗi nào đó và dấu hai chấm cuối cùng. Như với các định nghĩa hàm và các dòng tiêu đề khác, dấu hai chấm ở cuối dòng cho biết rằng một khối câu lệnh được thụt lề nhất quán theo sau để hoàn thành vòng lặp

1
2
3

8

1
2
3

8 mục

1
2
3

68 trình tự____302

câu lệnh thụt lề để lặp lại;

Khối các dòng được lặp lại một lần cho mỗi phần tử của chuỗi, vì vậy trong ví dụ này, hai dòng trong khối thụt lề được lặp lại ba lần. Hơn nữa, biến trong tiêu đề [

1
2
3

67 ở đây] có thể được sử dụng trong khối và mỗi lần nó nhận giá trị tiếp theo trong chuỗi, vì vậy lần đầu tiên qua vòng lặp

1
2
3

67 là 1, sau đó là 2 và cuối cùng là 3. Nhìn lại đầu ra và thấy rằng nó khớp với trình tự này. Một trình tự chi tiết hơn được đưa ra, chơi máy tính, trong bảng

Số dòngbình luận11bắt đầu với phần tử đầu tiên của danh sách21print 131‘yes’ * 1 is ‘yes’;

Khi thực hiện từng bước, lưu ý rằng tiêu đề vòng lặp

1
2
3

8 phục vụ hai mục đích

• Mỗi khi dòng tiêu đề thực thi, nó ngầm gán một giá trị mới cho tên biến mà bạn sử dụng thay cho mục
• Sau mỗi lần thực hiện dòng tiêu đề, các câu lệnh trong khối thụt lề được thực thi, thường sử dụng giá trị mới cho biến được gán trong tiêu đề

Ghi chú

Khi chơi máy tính với một vòng lặp, các số dòng giống nhau có thể xuất hiện lặp đi lặp lại, bởi vì dòng tiêu đề vòng lặp

1
2
3

8 và phần thân thụt vào bên dưới mỗi dòng được thực hiện lặp đi lặp lại. Mỗi khi một trong những dòng này được thực hiện, nó phải được liệt kê riêng, theo trình tự thời gian

Một vòng lặp

1
2
3

8 về mặt kỹ thuật là một câu lệnh ghép đơn. Mức thụt đầu dòng của nó được coi là mức độ thụt đầu dòng của tiêu đề

Khi bạn sử dụng Shell để nhập một vòng lặp, có một lý do khiến trình thông dịch đợi phản hồi cho đến khi bạn nhập một dòng trống. Thông dịch viên không biết khối vòng lặp sẽ kéo dài bao lâu. Dòng trống là tín hiệu cho trình thông dịch biết rằng bạn đã hoàn thành khối vòng lặp và do đó sẵn sàng thực hiện câu lệnh vòng lặp phức hợp hoàn chỉnh

Hãy xem chương trình ví dụ sau

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

08 và chạy nó

1
2
3

6

Trong một tệp mà người phiên dịch không cần trả lời ngay thì không cần dòng trống. Thay vào đó, như với một định nghĩa hàm hoặc bất kỳ định dạng nào khác có khối thụt lề, bạn cho biết đã vượt qua khối được thụt lề bằng cách thụt lề. Ở đây, câu lệnh

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

09 sau đây có cùng mức thụt đầu dòng như tiêu đề vòng lặp

1
2
3

8. Vì chúng có cùng mức thụt đầu dòng nên chúng được thực hiện theo thứ tự. Do đó trong đoạn mã trên, “Đếm xong. ” được in một lần sau khi vòng lặp đầu tiên hoàn thành tất cả các lần lặp lại của nó. Việc thực thi chương trình kết thúc bằng một vòng lặp đơn giản khác

Đối với khối thụt lề trong một hàm, điều quan trọng là phải thụt lề đúng cách. Thay đổi mã ở trên, để dòng thứ tư được thụt vào

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

0

Dự đoán thay đổi và chạy lại mã để kiểm tra

Vòng lặp là một trong những tính năng quan trọng nhất trong lập trình. Mặc dù cú pháp vòng lặp

1
2
3

8 khá đơn giản, nhưng việc sử dụng chúng một cách sáng tạo để giải quyết vấn đề [thay vì chỉ xem minh họa] là một trong những thách thức lớn nhất đối với nhiều người học ở cấp độ nhập môn. Một cách để đơn giản hóa đường cong học tập là phân loại các tình huống và mẫu thông thường và đặt tên cho chúng. Một trong những mẫu đơn giản nhất được minh họa trong tất cả các ví dụ về vòng lặp

1
2
3

8 cho đến nay, một vòng lặp for-each đơn giản. Đối với mỗi phần tử của chuỗi, hãy làm điều tương tự với nó. Được nêu dưới dạng mã giả Pythonic hơn

1
2
3

8 mục

1
2
3

68 trình tự____302

làm điều gì đó với mục hiện tại

[Nó thậm chí còn giống tiếng Anh hơn nếu thay thế

1
2
3

8 bằng

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

77, nhưng phiên bản ngắn hơn là phiên bản được sử dụng bởi Python. ]

Trong các ví dụ về vòng lặp

1
2
3

8 ở trên, nội dung nào đó được in ra có liên quan đến từng mục trong danh sách. In chắc chắn là một hình thức “làm gì đó”, nhưng khả năng “làm gì đó” là hoàn toàn chung chung

Chúng ta có thể sử dụng vòng lặp for-each để sửa lại ví dụ đầu tiên trong Hướng dẫn. Nhớ lại mã từ madlib. py

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

7

Mỗi dòng đang thực hiện chính xác cùng một việc, ngoại trừ việc thay đổi chuỗi được sử dụng làm gợi ý, trong khi lặp lại phần còn lại của dòng. Đây là mẫu cho từng mẫu, nhưng chúng ta cần liệt kê trình tự mà các tín hiệu đến từ. Đọc phương án thay thế

1
2
3
4
5

0

Xem tính năng này đòi hỏi khả năng trừu tượng hóa mẫu chung từ nhóm các ví dụ. Điều này là cần thiết để sử dụng các vòng lặp một cách hiệu quả

Nếu bạn muốn xem hoặc chạy toàn bộ chương trình với sửa đổi nhỏ này, hãy xem ví dụ

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

79. Một quy ước đặt tên phổ biến được sử dụng trong chương trình. Mỗi phần tử trong danh sách là một

1
2
3
4
5

00, trong khi danh sách có tất cả các phần tử được đặt tên bằng số nhiều

1
2
3
4
5

01. Trong các tình huống sau này, tôi đặt tên danh sách là số nhiều của tên biến được sử dụng cho một mục riêng lẻ của danh sách

Lưu ý logic chuyển đổi giữa hai phiên bản chương trình. Các phần dữ liệu thay thế được thu thập trong danh sách trong tiêu đề vòng lặp

1
2
3

8. Một tên biến duy nhất [ở đây tôi chọn

1
2
3
4
5

00] được sử dụng trong tiêu đề làm trình giữ chỗ để chỉ lựa chọn hiện tại đang được xử lý và phần thân đề cập đến biến này

1
2
3
4
5

00 thay cho các giá trị dữ liệu rõ ràng được đưa vào mỗi lần trong phần gốc

Điều quan trọng là phải hiểu chuỗi hoạt động, cách thực hiện qua lại giữa tiêu đề và nội dung. Đây là những thông tin chi tiết

1. đánh đầu lần đầu tiên. biến

   1
   2
   3
   4
   5

   00 được đặt thành phần tử đầu tiên của chuỗi,

   1
   2
   3
   4
   5

   06
2. cơ thể lần đầu tiên. vì

   1
   2
   3
   4
   5

   00 bây giờ là

   1
   2
   3
   4
   5

   06, hãy thực thi hiệu quả

   1
   2
   3
   4
   5

   09 [Bỏ qua chi tiết về lệnh gọi hàm trong phác thảo này. ]
3. đánh đầu lần thứ hai. biến

   1
   2
   3
   4
   5

   00 được đặt thành phần tử tiếp theo của chuỗi,

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   01
4. cơ thể lần thứ hai. vì

   1
   2
   3
   4
   5

   00 bây giờ là

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   01, thực hiện hiệu quả

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   04
5. đánh đầu lần thứ ba. biến

   1
   2
   3
   4
   5

   00 được đặt thành phần tử tiếp theo [cuối cùng] của chuỗi,

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   06
6. cơ thể lần thứ ba. vì

   1
   2
   3
   4
   5

   00 bây giờ là

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   06, thực hiện hiệu quả

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   09
7. tiêu đề được thực hiện. Vì không còn phần tử nào trong dãy, nên toàn bộ vòng lặp

   1
   2
   3

   8 được thực hiện và việc thực thi sẽ tiếp tục với câu lệnh sau nó [không thụt vào]

Trong ví dụ này, các giá trị dữ liệu chỉ là một vài chữ nhất định và chỉ có một dòng trong mẫu lặp lại. Do đó, việc sử dụng vòng lặp

1
2
3

8 không phải là vấn đề lớn, nhưng nó là một ví dụ đơn giản. Cấu trúc vòng lặp này sẽ thuận tiện hơn nhiều nếu bạn sửa đổi ví dụ mad lib ban đầu và có một câu chuyện với nhiều gợi ý hơn. Ngoài ra, bản sửa đổi này sẽ cho phép cải tiến thêm về , sau khi chúng tôi giới thiệu thêm về thao tác chuỗi

1. 13. 4. 1. Bài tập vòng lặp mẫu

Viết một vòng lặp for-each hai dòng trong tệp

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

12 có chứa lệnh gọi hàm

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

13, sao cho mã này với vòng lặp for-each tạo ra đầu ra được in giống hệt như mã trong tệp ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

14. Mã

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

14 được hiển thị bên dưới

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

0

Thực thi cả hai phiên bản để tự kiểm tra. gợi ý 1. gợi ý 2.

1. 13. 4. 2. Ba bài tập

Hoàn thành chức năng sau. Mã bắt đầu này nằm trong

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

16. Lưu nó với tên mới

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

17. Lưu ý cách một ví dụ được đưa ra trong chuỗi tài liệu. Nó mô phỏng việc sử dụng hàm trong Shell. Đây là quy ước chung

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

1

Các phần tử của danh sách trong tiêu đề vòng lặp

1
2
3

8 không phải tất cả cùng loại. Bạn cần sử dụng biến vòng lặp hai lần trong thân vòng lặp

1. 13. 5. Vòng lặp đơn giản

Các ví dụ trên đều sử dụng giá trị của biến trong tiêu đề vòng lặp

1
2
3

8. Cách sử dụng vòng lặp

1
2
3

8 thậm chí còn đơn giản hơn là khi bạn chỉ muốn lặp lại chính xác điều tương tự trong một số lần cụ thể. Trong trường hợp đó, chỉ độ dài của chuỗi chứ không phải các phần tử riêng lẻ là quan trọng. Chúng ta đã thấy rằng hàm

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

4 cung cấp một cách dễ dàng để tạo ra một chuỗi với một số phần tử xác định. Đọc và chạy chương trình ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

22

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

2

Trong tình huống này, biến

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

23 không được sử dụng bên trong phần thân của vòng lặp for

Người dùng có thể chọn số lần lặp lại. Đọc và chạy chương trình ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

24

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

3

Khi bạn đang đọc mã, bạn nhìn vào các tên biến khi chúng được giới thiệu và xem chúng được sử dụng ở đâu sau này. Trong các vòng lặp đơn giản ở trên, biến vòng lặp

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

23 được giới thiệu, bởi vì phải có một tên biến ở đó, nhưng nó không bao giờ được sử dụng

Một quy ước để chỉ ra biến vòng lặp đơn giản không bao giờ được sử dụng nữa, đó là sử dụng tên biến đặc biệt

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

26 [chỉ là dấu gạch dưới], như trong

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

4

1. 13. 6. Vòng lặp sửa đổi liên tiếp

Giả sử tôi có một danh sách các mục có tên là

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

27 và tôi muốn in ra từng mục và đánh số chúng liên tiếp. Chẳng hạn, nếu

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

27 là

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

29, tôi muốn xem đầu ra

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

5

Đọc về quá trình suy nghĩ sau đây để phát triển điều này

Nếu tôi cho phép mình bỏ qua những con số, nó rất dễ dàng. Đối với bất kỳ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

30 nào trong danh sách, tôi có thể xử lý nó bằng

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

6

và tôi chỉ xem qua danh sách và làm điều đó cho từng người. [Copy và chạy nếu bạn thích. ]

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

7

Rõ ràng phiên bản phức tạp hơn với các con số có hoa văn nhất quán, mỗi dòng ít nhất là ở dạng

mục số

nhưng số thay đổi mỗi lần và các số không xuất hiện trực tiếp từ danh sách các mục

Một biến có thể thay đổi, do đó, thật hợp lý khi có một biến

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

31, vì vậy chúng tôi có khả năng làm cho nó thay đổi một cách chính xác. Chúng tôi có thể dễ dàng đạt được ngay lần đầu tiên và sau đó lặp lại cùng một con số. Đọc và chạy chương trình ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

32

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

8

Tất nhiên điều này vẫn chưa hoàn toàn chính xác, vì ý tưởng là đếm. Sau khi số lần đầu tiên được in, nó cần được thay đổi thành 2, để đúng trong lần tiếp theo thông qua vòng lặp, như trong đoạn mã sau. Đọc và chạy chương trình ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

33

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

9

Điều này gần hơn, nhưng vẫn không hoàn toàn chính xác, vì chúng tôi không bao giờ đạt đến 3. Chúng tôi cần một cách để thay đổi giá trị của số sẽ hoạt động mỗi lần qua vòng lặp. Mô hình đếm rất đơn giản, đơn giản đến mức bạn có thể không suy nghĩ một cách có ý thức về cách bạn đi từ số này sang số tiếp theo. Bạn có thể mô tả mô hình bằng cách nói rằng mỗi số tiếp theo nhiều hơn một số so với số trước đó. Chúng tôi cần có khả năng thay đổi

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

31 để nó nhiều hơn một lần so với trước đây. Đó là ý tưởng bổ sung chúng ta cần. Thay đổi dòng cuối cùng của thân vòng lặp để lấy chương trình ví dụ numberEntries3. py. Xem phần bổ sung và chạy nó

1
2
3
4
5

['red', 'green', 'blue']
[1, 3, 5, 7, 9, 11]
['silly', 57, 'mixed', -23, 'example']
[] # the empty list
[ [7, 11], [1], [] ] # list containing three elements; each a list

1

Điều quan trọng là phải hiểu các thay đổi từng bước trong quá trình thực hiện. Dưới đây là một bảng khác hiển thị kết quả chơi máy tính. Các số dòng quan trọng hơn nhiều ở đây để theo dõi luồng điều khiển, do nhảy xung quanh ở cuối vòng lặp

Một lần nữa lưu ý rằng các số dòng chương trình trong cột Dòng của bảng máy tính chơi không được liệt kê theo thứ tự, bởi vì dòng tiêu đề vòng lặp

1
2
3

8 và phần thân thụt vào bên dưới mỗi dòng được thực hiện lặp đi lặp lại

Để cho gọn, biến

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

27 không có cột riêng vì nó luôn có giá trị như trong chú thích ở dòng 1

lineitemnumbercomment1--đặt các mục thành ['đỏ', 'cam','vàng', 'xanh lá cây']2-1 3'đỏ'1bắt đầu với mục đầu tiên trong chuỗi4'đỏ'1in. 1 red5'red'22 = 1+13'orange'2vào phần tử tiếp theo trong dãy4'orange'2in 2 orange5'orange'33=2+13'yellow'3vào phần tử tiếp theo trong dãy4'yellow'3in 3 yellow5

Giá trị cuối cùng của số không bao giờ được sử dụng, nhưng điều đó không sao. Những gì chúng tôi muốn được in

Xem kỹ và đảm bảo rằng bạn hiểu ý nghĩa của từng mục trong bảng, lý do sắp xếp thứ tự và lý do vị trí chính xác của từng mục trong mỗi bước mà nó thay đổi. Cụ thể, hãy xem cách thức và lý do tại sao số dòng cho mỗi hàng kế tiếp không phải lúc nào cũng nhiều hơn hàng trước đó. Cụ thể, hãy xem cách lặp lại cùng một chuỗi các dòng được đánh số ở nhiều vị trí trong bảng. Nếu không có sự hiểu biết này, bạn sẽ không thể tự chơi máy tính và thực sự hiểu các vòng lặp

Ví dụ ngắn này minh họa rất nhiều ý tưởng quan trọng đối với các vòng lặp

• Vòng lặp có thể chứa một số biến
• Một cách mà biến có thể thay đổi là trở thành biến trong tiêu đề vòng lặp ________ 08, tự động đi qua các giá trị trong danh sách vòng lặp ________ 08
• Một cách khác để các biến thay đổi trong một vòng lặp là có một câu lệnh rõ ràng làm thay đổi biến bên trong vòng lặp, gây ra các sửa đổi liên tiếp

Có một khuôn mẫu chung cho các vòng lặp với sự sửa đổi liên tiếp của một biến như

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

31 ở trên

1. Các biến cần sửa đổi cần có giá trị ban đầu trước vòng lặp [dòng 1 trong ví dụ trên]
2. Tiêu đề vòng lặp gây ra sự lặp lại. Trong một vòng lặp for, số lần lặp lại giống như kích thước của danh sách
3. Phần thân của vòng lặp nói chung là "làm điều gì đó" [như in ở dòng 4] mà bạn muốn thực hiện lặp đi lặp lại
4. Có mã bên trong phần thân của vòng lặp để thiết lập cho lần tiếp theo thông qua vòng lặp, trong đó biến cần thay đổi được chuyển thành giá trị tiếp theo của nó [dòng 5 trong ví dụ trên]

Thông tin này có thể được đưa vào một phác thảo mã

Khởi tạo các biến cần sửa đổi

Tiêu đề vòng lặp kiểm soát sự lặp lại

Thực hiện hành động mong muốn với các biến hiện tại

Sửa đổi các biến để sẵn sàng cho hành động vào lần tiếp theo

Nếu bạn so sánh mẫu này với các vòng lặp for-each và lặp lại đơn giản trong , bạn sẽ thấy rằng các ví dụ ở đó đơn giản hơn. Không cần sửa đổi biến rõ ràng để chuẩn bị cho lần tiếp theo thông qua vòng lặp. Chúng tôi sẽ đề cập đến mẫu mới nhất, tổng quát hơn như một vòng lặp sửa đổi liên tiếp

Các hàm tiện dụng để đóng gói một ý tưởng để sử dụng và tái sử dụng trong một chương trình cũng như để thử nghiệm. Chúng ta có thể viết một hàm để đánh số thứ tự một danh sách và dễ dàng kiểm tra nó với các dữ liệu khác nhau. Đọc và chạy chương trình ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

40

['red', 'green', 'blue']
[1, 3, 5, 7, 9, 11]
['silly', 57, 'mixed', -23, 'example']
[] # the empty list
[ [7, 11], [1], [] ] # list containing three elements; each a list

2

Đảm bảo rằng bạn có thể làm theo toàn bộ trình tự, từng bước một. Chương trình này có luồng điều khiển phức tạp nhất từ ​​trước đến nay, thay đổi cả đối với lệnh gọi hàm và vòng lặp

1. Thực thi bắt đầu với dòng cuối cùng, vì các dòng trước đó là định nghĩa

2. Sau đó,

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   41 bắt đầu thực thi

3. Cuộc gọi đầu tiên tới

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   42 đặt tham số chính thức một cách hiệu quả

   ['red', 'green', 'blue']
   [1, 3, 5, 7, 9, 11]
   ['silly', 57, 'mixed', -23, 'example']
   [] # the empty list
   [ [7, 11], [1], [] ] # list containing three elements; each a list
   

   3

   và chức năng thực thi giống như quy trình tiếp theo trong

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   43. Tuy nhiên, lần này, việc thực thi quay trở lại chính

4. Một dòng trống được in trong dòng thứ hai của lệnh chính

5. Cuộc gọi thứ hai tới

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   42 có một tham số thực tế khác là

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   45, vì vậy, lần này sẽ đặt tham số chính thức một cách hiệu quả

   ['red', 'green', 'blue']
   [1, 3, 5, 7, 9, 11]
   ['silly', 57, 'mixed', -23, 'example']
   [] # the empty list
   [ [7, 11], [1], [] ] # list containing three elements; each a list
   

   4

   và hàm thực thi theo mẫu tương tự như trong

   x = 3      # simple sequential code
   y = x + 2  # updating two variables
   y = 2*y        
   x = y - x      
   print[x, y]    
   

   43, nhưng với dữ liệu khác và vòng lặp ít hơn một lần

6. Thực thi trở lại chính, nhưng không có gì khác để làm

1. 13. 7. vòng tích lũy

Giả sử bạn muốn cộng tất cả các số trong một danh sách,

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

47. Hãy để chúng tôi lập kế hoạch này như một chức năng ngay từ đầu, vì vậy hãy đọc mã bên dưới. Chúng ta có thể bắt đầu với

['red', 'green', 'blue']
[1, 3, 5, 7, 9, 11]
['silly', 57, 'mixed', -23, 'example']
[] # the empty list
[ [7, 11], [1], [] ] # list containing three elements; each a list

5

Nếu bạn không biết phải làm gì ngay lập tức, điều hữu ích nên làm là viết ra một trường hợp cụ thể và nghĩ cách bạn sẽ giải quyết nó một cách chi tiết đầy đủ. Nếu

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

47 là

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

49, bạn có thể sẽ tính toán

2 + 6 là 8

8 + 3 là 11

11 + 8 là 19

19 là câu trả lời được trả lại

Vì danh sách có thể dài tùy ý, bạn cần một vòng lặp. Do đó, bạn phải tìm một mẫu để bạn có thể tiếp tục sử dụng lại các câu lệnh tương tự trong vòng lặp. Rõ ràng là bạn đang sử dụng từng số trong dãy theo thứ tự. Bạn cũng tạo ra một tổng trong mỗi bước, mà bạn sử dụng lại trong bước tiếp theo. Mô hình là khác nhau, tuy nhiên, ở dòng đầu tiên, 2 + 6 là 8. không có tổng trước đó và bạn sử dụng hai phần tử từ danh sách. 2 không được cộng vào tổng trước đó

Mặc dù đây không phải là cách ngắn nhất để tính toán bằng tay, nhưng 2 là tổng của 0 + 2. Chúng ta có thể làm cho mẫu nhất quán và tính toán

bắt đầu với tổng bằng 0

0 + 2 là 2

2 + 6 là 8

8 + 3 là 11

11 + 8 là 19

19 là câu trả lời

Sau đó, phần thứ hai của mỗi tổng là một số từ danh sách,

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

47. Nếu chúng ta gọi số từ danh sách

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

51, dòng tính toán chính trong vòng lặp có thể là

['red', 'green', 'blue']
[1, 3, 5, 7, 9, 11]
['silly', 57, 'mixed', -23, 'example']
[] # the empty list
[ [7, 11], [1], [] ] # list containing three elements; each a list

6

Bí quyết là sử dụng cùng một dòng mã vào lần tiếp theo thông qua vòng lặp. Điều đó có nghĩa là những gì là ________ 652 trong một lượt sẽ trở thành ________ 653 trong lượt tiếp theo. Một cách để xử lý đó là

['red', 'green', 'blue']
[1, 3, 5, 7, 9, 11]
['silly', 57, 'mixed', -23, 'example']
[] # the empty list
[ [7, 11], [1], [] ] # list containing three elements; each a list

7

Bạn có thấy mô hình?

khởi tạo

tiêu đề vòng lặp

công việc chính được lặp lại

chuẩn bị cho lần tiếp theo thông qua vòng lặp

Đôi khi hai bước lặp chung có thể được kết hợp. Đây là một trường hợp như vậy. Vì

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

52 chỉ được sử dụng một lần, chúng tôi chỉ có thể thay thế giá trị của nó [

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

53] nơi nó được sử dụng và đơn giản hóa thành

['red', 'green', 'blue']
[1, 3, 5, 7, 9, 11]
['silly', 57, 'mixed', -23, 'example']
[] # the empty list
[ [7, 11], [1], [] ] # list containing three elements; each a list

8

vì vậy toàn bộ chức năng, với câu lệnh

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

56 là

['red', 'green', 'blue']
[1, 3, 5, 7, 9, 11]
['silly', 57, 'mixed', -23, 'example']
[] # the empty list
[ [7, 11], [1], [] ] # list containing three elements; each a list

9

1
2
3

10

Chương trình ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

57 có đoạn mã trên với dòng sau được thêm vào cuối để kiểm tra chức năng [không thụt lề]. Chạy

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

57

1
2
3

11

Mẫu được sử dụng ở đây chắc chắn là sửa đổi liên tiếp [của biến

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

53]. Sẽ rất hữu ích khi đặt tên chuyên biệt hơn cho phiên bản mẫu này tại đây. Nó tuân theo một mô hình tích lũy

khởi tạo sự tích lũy để không bao gồm chuỗi nào [

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

60 ở đây]

1
2
3

8 mục

1
2
3

68 trình tự

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

02

giá trị tích lũy mới = kết quả của việc kết hợp vật phẩm với giá trị tích lũy cuối cùng

Mẫu này sẽ hoạt động trong nhiều tình huống khác ngoài việc thêm số

thuật ngữ vòng lặp tiếng anh. Tất nhiên, bạn cần có khả năng chuyển từ mô tả vấn đề bằng tiếng Anh sang kế hoạch và sau đó triển khai nó bằng Python. Đặc biệt, điều rất quan trọng là nhận ra khi nào bạn cần chương trình của mình có một vòng lặp thông qua một chuỗi. Một số từ hoặc cụm từ phổ biến gợi ý một vòng lặp là gì? .

Khi bạn thấy nhu cầu về vòng lặp này, bạn cần lập kế hoạch cho mã của mình. Có rất nhiều câu hỏi mà bạn có thể thường xuyên tự hỏi mình về việc hoàn thiện dàn ý cho phần vòng lặp trong mã của mình

khởi tạo

tiêu đề vòng lặp

công việc chính được lặp lại

chuẩn bị cho lần tiếp theo thông qua vòng lặp

1. Trình tự là gì?
2. Viết tiêu đề vòng lặp

   1
   2
   3

   8. Với quyết định này, bạn không còn cần phải suy nghĩ về toàn bộ chương trình cùng một lúc. Bạn có thể tập trung vào những gì bạn làm cho một phần tử, với tên bạn đã đặt trong tiêu đề vòng lặp
3. Tôi cần làm gì cho một phần tử của chuỗi?
4. Hành động chính có liên quan đến một biến, ngoài biến vòng lặp, cần thay đổi mỗi lần qua vòng lặp không? . Cuối cùng, mã cập nhật này

1. 13. 7. 1. Chơi máy tính sumList Bài tập

Giả sử hàm

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

65, được xác định ở trên, được gọi với tham số

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

66. Chơi máy tính trong cuộc gọi này, sử dụng tệp

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

67, được mở từ cửa sổ hệ điều hành cho thư mục ví dụ. Không mở ở chế độ Chờ. Tệp sẽ xuất hiện trong trình xử lý văn bản thông thường của bạn. Ngay lập tức lưu tệp dưới dạng

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

68 và điền vào các ô trống trong bảng

Đảm bảo rằng có một hàng trong bảng cho mỗi dòng được thực thi trong chương trình, với một mục nhập dòng riêng cho mỗi lần một dòng được thực thi. Trong mỗi hàng, hãy nhập dòng chương trình nào đang được thực thi và hiển thị tất cả các thay đổi gây ra cho các biến khi thực hiện một dòng đó. Hiển thị số dòng như được hiển thị ở lề bên cạnh mã ví dụ trong Hướng dẫn. [Bản thân các tệp Python riêng biệt không hiển thị số dòng. ] Một bảng được bắt đầu cho bạn dưới đây. Hàng cuối cùng mà bạn nhập trong bảng của mình phải dành cho việc thực thi dòng được đánh số 6 trong mã và nhận xét của bạn có thể là "return 18"

Nếu cùng một giá trị biến trong một cột lặp lại qua một số hàng, sẽ thuận tiện hơn nếu chỉ để trống các mục nhập sau thay vì tiếp tục sao chép. Với quy ước này, giá trị hiện tại của một biến là giá trị cuối cùng được ghi ở dòng trước đó trong bảng

Đây là bài tập “Chơi máy tính” đầu tiên có vòng lặp. Hãy nhớ xem lại các ví dụ chơi trên máy tính trước đó. Các dòng trong vòng lặp [và do đó là số dòng của chúng] lặp lại nhiều lần dưới dạng các hàng trong bảng, khi bạn đi theo vòng lặp hết lần này đến lần khác

Tham số gốc, không thay đổi, không có cột trong bảng, cho gọn. Sự bắt đầu của bảng được hiển thị dưới đây. Như được hiển thị trong nhận xét đầu tiên, trong suốt cuộc gọi hàm,

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

47 là

1
2
3

12

Linesumnumcomment1--đặt số thành [5, 2, 4, 7];

1. 13. 7. 2. Kiểm tra sumList Bài tập

Viết chương trình

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

70 bao gồm hàm

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

41 để kiểm tra hàm sumList nhiều lần. Bao gồm một bài kiểm tra cho trường hợp cực đoan, với một danh sách trống

1. 13. 7. 3. Tham gia tất cả các bài tập

* Hoàn thành chức năng sau. Mã bắt đầu này nằm trong

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

72. Lưu nó vào tên mới

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

73. Lưu ý cách một ví dụ được đưa ra trong chuỗi tài liệu. Nó mô phỏng việc sử dụng hàm trong Shell. Đây là quy ước chung

1
2
3

13

Gợi ý đầu tiên. Gợi ý thứ hai.

1. 13. 8. Chơi máy tính nhiều hơn

Kiểm tra mã bằng cách chạy nó cũng được, nhưng nhìn vào kết quả không có nghĩa là bạn thực sự hiểu chuyện gì đang xảy ra, đặc biệt nếu có lỗi. Những người không hiểu chuyện gì đang xảy ra có khả năng thực hiện các thay đổi ngẫu nhiên đối với mã của họ nhằm cố gắng sửa lỗi. Đây là một thói quen rất tồi tệ, ngày càng tự chuốc lấy thất bại, vì bạn có thể sẽ không bao giờ biết được vấn đề thực sự nằm ở đâu và vấn đề tương tự có thể sẽ quay lại cắn bạn.

Điều quan trọng là có thể dự đoán chính xác mã sẽ làm gì. Chúng tôi đã minh họa việc chơi máy tính trên nhiều đoạn mã nhỏ khác nhau

Chơi máy tính có thể giúp bạn tìm lỗi [lỗi trong mã của bạn]. Một số lỗi là lỗi cú pháp do trình thông dịch bắt được trong bản dịch. Một số lỗi chỉ được trình thông dịch bắt gặp trong khi thực thi, chẳng hạn như không có giá trị cho một biến bạn sử dụng. Các lỗi khác hoàn toàn không được thông dịch viên bắt được - bạn chỉ nhận được câu trả lời sai. Chúng được gọi là lỗi logic. Các lỗi logic trước đó cũng có thể gây ra lỗi thực thi sau này. Đây là khi chơi máy tính đặc biệt hữu ích

Một lỗi phổ biến khi cố viết hàm

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

42 là có đoạn mã sau [trích từ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

75]

['red', 'green', 'blue']
[1, 3, 5, 7, 9, 11]
['silly', 57, 'mixed', -23, 'example']
[] # the empty list
[ [7, 11], [1], [] ] # list containing three elements; each a list

9

1
2
3

15

Bạn có thể chạy mã này và thấy rằng nó tạo ra câu trả lời sai. Nếu bạn chơi máy tính trên cuộc gọi đến

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

76, bạn có thể thấy vấn đề

Số mục hàngNhận xét1--đặt các mục thành [‘apples’, ‘lê’, ‘chuối’]3‘apples’-bắt đầu với mục đầu tiên trong chuỗi 4‘apples’1 5‘apples’11 in. 1 quả táo6‘quả táo’22 = 1+13‘quả lê’2đến phần tử tiếp theo trong chuỗi4‘quả lê’1 5‘quả lê’1 bản in. 1 quả lê

Nếu bạn đi từng bước một, bạn sẽ thấy 1 cái sai đến từ đâu. việc khởi tạo được lặp lại mỗi lần trong vòng lặp ở dòng 4, hoàn tác việc tăng

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

31 ở dòng 6, làm rối tung số đếm của bạn

Cảnh báo

Luôn cẩn thận rằng việc khởi tạo một lần của bạn cho một vòng lặp diễn ra trước vòng lặp, không phải trong vòng lặp đó

Hàm cũng có thể trả về giá trị. Hãy xem xét Python cho chuỗi toán học này. xác định hàm m[x] = 5x, đặt y = 3;

1
2
3
4
5

1
2
3

17

Mã này là ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

78. Một ví dụ tương tự đã được xem xét trong , nhưng bây giờ thêm ý tưởng chơi máy tính và ghi trình tự vào bảng. Giống như khi bạn đơn giản hóa một biểu thức toán học, Python phải hoàn thành những phần trong cùng trước. Theo dõi các thay đổi có nghĩa là tuân theo các lời gọi hàm một cách cẩn thận và sử dụng các giá trị được trả về. Một lần nữa, dấu gạch ngang '-' được sử dụng trong bảng để biểu thị một biến không xác định. Không chỉ các biến cục bộ như tham số chính thức không được xác định trước khi chúng được sử dụng lần đầu tiên, chúng cũng không được xác định sau khi kết thúc hàm,

LinexyComment1-3  Ghi nhớ định nghĩa của m4-3 5-3bắt đầu từ. in[m[y] + m[2*y-1]]; . print[15 + m[2*y-1]], muốn m[2*y-1], là m[2*3-1] = m[5]153 chuyển 5 cho hàm m, vì vậy x=5253return 5 . in [15 + 25], vì vậy hãy tính và in ra 40

Cho đến nay, hầu hết các mã được cung cấp đã được thúc đẩy trước, vì vậy bạn có thể biết những gì sẽ xảy ra. Bạn có thể cần đọc mã do người khác viết [hoặc thậm chí là chính bạn trước đây. ] nơi bạn không chắc chắn những gì được dự định. Ngoài ra, bạn có thể mắc lỗi và vô tình viết mã làm điều gì đó ngoài ý muốn. Nếu bạn thực sự hiểu cách thức hoạt động của Python, từng dòng một, bạn sẽ có thể chơi máy tính và làm theo ít nhất các chuỗi mã ngắn chưa được giải thích trước đây. Sẽ rất hữu ích khi đọc mã của người khác và cố gắng làm theo nó. Các bài tập tiếp theo cũng cung cấp các mã chưa được giải thích trước hoặc có lỗi

1. 13. 8. 1. Chơi bài tập vòng lặp lẻ trên máy tính

* Làm việc trong trình xử lý văn bản [không phải Idle. ], bắt đầu từ ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

79 và lưu tệp dưới dạng

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

80. Trong file có lập bảng cho bài này và 2 bài tập sau

Chơi máy tính trên đoạn mã sau

['red', 'green', 'blue']
[1, 3, 5, 7, 9, 11]
['silly', 57, 'mixed', -23, 'example']
[] # the empty list
[ [7, 11], [1], [] ] # list containing three elements; each a list

9

1
2
3

19

Kiểm tra thực tế. 31 được in khi dòng 6 cuối cùng thực thi. Bắt đầu bảng cho bài tập này được hiển thị dưới đây

LinexynBình luận10

1. 13. 8. 2. Chơi bài tập lỗi máy tính

* Trong trình xử lý văn bản, hãy thêm vào tệp

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

80, đã bắt đầu trong bài tập trước

Đoạn mã sau được cho là tính tích của các số trong danh sách. Ví dụ:

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

82 sẽ tính và trả về 5*4*6=120 theo các bước, tính 5, 5*4=20 và 20*6=120

1
2
3
4
5

1
2
3

1

Mã cho bài tập này xuất hiện trong tệp ví dụ

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

83

Công dụng chính của việc chơi máy tính là để xem chính xác nơi dữ liệu mà bạn mong đợi bị xáo trộn. Chơi máy tính trên một cuộc gọi đến

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

82 cho đến khi bạn thấy rằng nó mắc lỗi và tạo ra một số sai. Sau đó, bạn có thể ngừng mở rộng bảng, chỉ cần kết thúc bằng nhận xét về cách hiển thị lỗi hiện tại

Tiêu đề bảng và hàng đầu tiên của bảng cho bài tập này được hiển thị bên dưới

LinenprodComment1--Đặt số thành [5, 4, 6]2

Sau đó, bạn có thể dừng lại và sửa chữa nó. Trước tiên, sao chép

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

83 sang

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

86 và sửa tệp mới [và lưu lại. ]

1. 13. 8. 3. Chơi bài tập chức năng máy tính

* Trong trình xử lý văn bản, hãy thêm một lần nữa vào tệp

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

80, đã bắt đầu trong các bài tập trước

Chơi máy tính trên đoạn mã sau

1
2
3

1
2
3

3

Kiểm tra thực tế. 70 được in

Tiêu đề bảng và hàng đầu tiên của bảng cho bài tập này được hiển thị bên dưới

LinexComment1-2 Ghi nhớ định nghĩa f3

Bạn sẽ xem lại dòng 3 nhiều lần, với các dòng bảng thực thi hàm

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

88 xen kẽ. Nhìn vào ví dụ trên có một bảng hiển thị hàm

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

89 trả về một giá trị hai lần

1. 13. 9. Từ khóa hàm

for count in [1, 2, 3]: 
    print[count] 
    print['Yes' * count] 

09

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

91

Theo mặc định, chức năng in thêm một dòng mới vào cuối chuỗi được in. Điều này có thể được ghi đè bằng cách bao gồm tham số từ khóa

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

91. Kết thúc từ khóa có thể được đặt bằng bất kỳ chuỗi nào. Các thay thế phổ biến nhất là chuỗi trống hoặc một ô trống. Nếu bạn cũng sử dụng tham số từ khóa

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

93, thì các tham số từ khóa này có thể theo một trong hai thứ tự, nhưng tham số từ khóa phải ở cuối danh sách tham số. Đọc hình ảnh minh họa

1
2
3

4

tương đương với

1
2
3

5

Điều này không hoạt động trực tiếp trong trình bao [nơi bạn luôn bị buộc phải chuyển sang một dòng mới ở cuối]. Nó hoạt động trong một chương trình, nhưng nó không hữu ích lắm ngoại trừ trong một vòng lặp

Giả sử tôi muốn in một dòng có tất cả các thành phần của danh sách, được phân tách bằng dấu cách, nhưng không phải trên các dòng riêng biệt. Tôi có thể sử dụng từ khóa

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

91 được đặt thành khoảng trắng trong vòng lặp. Bạn có thể hình dung trong đầu tệp ví dụ này

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

95 làm gì không?

1
2
3

6

Nếu bạn vẫn muốn chuyển sang một dòng mới ở cuối vòng lặp, bạn phải bao gồm chức năng in chuyển sang dòng tiếp theo, một lần, sau vòng lặp. Hãy thử biến thể này,

x = 3      # simple sequential code
y = x + 2  # updating two variables
y = 2*y        
x = y - x      
print[x, y]    

96

Chúng ta có thể thay đổi giá trị I trong vòng lặp Python không?

Tôi có thể thay đổi giá trị I bên trong vòng lặp không?

Chúng ta có thể gán biến cho vòng lặp không?

Làm cách nào tôi có thể thay thế vòng lặp trong Python?