Trong bài học trước, chúng tôi đã viết một số mã biểu thị một số giá trị quan tâm từ tập dữ liệu viêm đầu tiên của chúng tôi và tiết lộ một số tính năng đáng ngờ trong đó, chẳng hạn như từ
word = 'tin'
print[word[0]]
print[word[1]]
print[word[2]]
print[word[3]]
9Tuy nhiên, hiện tại chúng tôi có hàng tá bộ dữ liệu và còn nhiều bộ nữa trong tương lai. 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 ta có thể muốn lặp lại là in từng ký tự trong một từ trên một dòng của chính nó
Chúng ta có thể truy cập một ký tự trong chuỗi bằng cách sử dụng chỉ mục của nó. Ví dụ: chúng ta có thể lấy ký tự đầu tiên của từ 'lead', bằng cách sử dụng word[0]. Một cách để in từng ký tự là sử dụng bốn câu lệnh
---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
0print[word[0]]
print[word[1]]
print[word[2]]
print[word[3]]
Đây là một cách tiếp cận tồi vì hai lý do
Nó không quy mô. nếu chúng tôi muốn in các ký tự trong một chuỗi dài hàng trăm ký tự, tốt hơn hết chúng tôi chỉ cần nhập chúng vào
Nó mong manh. nếu chúng tôi cung cấp cho nó một chuỗi dài hơn, nó chỉ in một phần dữ liệu và nếu chúng tôi cung cấp cho nó một chuỗi ngắn hơn, nó sẽ tạo ra lỗi vì chúng tôi đang yêu cầu các ký tự không tồn tại
word = 'tin'
print[word[0]]
print[word[1]]
print[word[2]]
print[word[3]]
---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
Đây là một cách tiếp cận tốt hơn
word = 'lead'
for char in word:
print[char]
Cái này ngắn hơn—chắc chắn là ngắn hơn cái gì đó in mọi ký tự trong một chuỗi hàng trăm ký tự—và cũng mạnh mẽ hơn
word = 'oxygen'
for char in word:
print[char]
Phiên bản cải tiến sử dụng vòng lặp for để 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à
for element in variable:
do things with element
Sử dụng ví dụ oxy ở trên, vòng lặp có thể trông như thế này
trong đó mỗi ký tự [
---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
1] trong biến ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
2 được lặp lại và in hết ký tự này đến ký tự khác. Các số trong sơ đồ biểu thị chu kỳ vòng lặp mà ký tự được in [1 là vòng lặp đầu tiên và 6 là vòng lặp cuối cùng]Chúng ta có thể gọi biến vòng lặp bất cứ thứ gì chúng ta muốn, 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. kết thúc cho];
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à
1 để ghi nhớ; . 'Char' không phải là một từ khóa trong Python kéo các ký tự từ các từ hoặc chuỗi. Trong thực tế, khi một vòng lặp tương tự được chạy trên một danh sách chứ không phải một từ, đầu ra sẽ là từng thành viên của danh sách đó được in theo thứ tự, thay vì các ký tự--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[word[1]] 4 print[word[2]] ----> 5 print[word[3]] IndexError: string index out of range
1--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[word[1]] 4 print[word[2]] ----> 5 print[word[3]] IndexError: string index out of range
2--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[word[1]] 4 print[word[2]] ----> 5 print[word[3]] IndexError: string index out of range
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
4 cho biến vòng lặp, miễn là chúng ta sử dụng cùng tên khi gọi biến bên trong vòng lặp--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[word[1]] 4 print[word[2]] ----> 5 print[word[3]] IndexError: string index out of range
4--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[word[1]] 4 print[word[2]] ----> 5 print[word[3]] IndexError: string index out of range
5--------------------------------------------------------------------------- IndexError Traceback [most recent call last] in [] 3 print[word[1]] 4 print[word[2]] ----> 5 print[word[3]] IndexError: string index out of range
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
word = 'tin'
print[word[0]]
print[word[1]]
print[word[2]]
print[word[3]]
0Thật đáng để theo dõi từng bước thực hiện chương trình nhỏ này. Vì có năm ký tự trong
---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
5 nên câu lệnh ở dòng 3 sẽ được thực hiện năm lần. Lần đầu tiên, ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
6 bằng 0 [giá trị được gán cho nó ở dòng 1] và ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
7 là ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
8. Câu lệnh thêm 1 vào giá trị cũ của ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
6, tạo ra 1 và cập nhật ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
6 để chỉ giá trị mới đó. Khoảng thời gian tiếp theo, ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
7 là word = 'lead'
for char in word:
print[char]
2 và ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
6 là 1, vì vậy, ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
6 được cập nhật thành 2. Sau ba lần cập nhật nữa, ---------------------------------------------------------------------------
IndexError Traceback [most recent call last]
in []
3 print[word[1]]
4 print[word[2]]
----> 5 print[word[3]]
IndexError: string index out of range
6 là 5; Lưu ý rằng một biến vòng lặp chỉ 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
word = 'tin'
print[word[0]]
print[word[1]]
print[word[2]]
print[word[3]]
1word = 'tin'
print[word[0]]
print[word[1]]
print[word[2]]
print[word[3]]
2Cũng lưu ý rằng việc tìm độ dài của một chuỗi 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à
word = 'lead'
for char in word:
print[char]
8word = 'lead'
for char in word:
print[char]
8 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à
0 để tạo một dãy số. Phạm vi có thể chấp nhận 1-3 tham số. Nếu một tham số được nhập vào, phạm vi sẽ tạo một mảng có độ dài đó, bắt đầu từ 0 và tăng dần 1. Nếu 2 tham số được nhập vào, phạm vi sẽ bắt đầu ở tham số đầu tiên và kết thúc ngay trước tham số thứ hai, tăng dần theo một. Nếu phạm vi được truyền 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ụ:word = 'oxygen' for char in word: print[char]
1 tạo ra các số 0, 1, 2, trong khiword = 'oxygen' for char in word: print[char]
2 tạo ra 2, 3, 4 vàword = 'oxygen' for char in word: print[char]
3 tạo ra 3, 6, 9. Sử dụngword = 'oxygen' for char in word: print[char]
0, viết một vòng lặp sử dụngword = 'oxygen' for char in word: print[char]
0 để in ra 3 số tự nhiên đầu tiênword = 'oxygen' for char in word: print[char]
Dung dịch
3word = 'tin' print[word[0]] print[word[1]] print[word[2]] print[word[3]]
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
Viết một vòng lặp tính toán kết quả tương tự như
6 bằng cách sử dụng phép nhân [và không có lũy thừa]word = 'oxygen' for char in word: print[char]
Dung dịch
4word = 'tin' print[word[0]] print[word[1]] print[word[2]] print[word[3]]
Đảo ngược một chuỗi
Viết một vòng lặp nhận vào một chuỗi và tạo ra một chuỗi mới với các ký tự theo thứ tự ngược lại, do đó,
7 trở thànhword = 'oxygen' for char in word: print[char]
8word = 'oxygen' for char in word: print[char]
Dung dịch
5word = 'tin' print[word[0]] print[word[1]] print[word[2]] print[word[3]]
Tính giá trị của một đa thức
Hàm dựng sẵn
9 lấy 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 chứa chỉ số [0,1,2,…] và giá trị từ dãy ban đầuword = 'oxygen' for char in word: print[char]
6word = 'tin' print[word[0]] print[word[1]] print[word[2]] print[word[3]]
Vòng lặp trên gán chỉ số cho
0 và giá trị chofor element in variable: do things with element
1for element in variable: do things with element
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.
7word = 'tin' print[word[0]] print[word[1]] print[word[2]] print[word[3]]
Viết một vòng lặp sử dụng
2 để tính giá trịfor element in variable: do things with element
3 của bất kỳ đa thức nào, cho trướcfor element in variable: do things with element
1 vàfor element in variable: do things with element
5for element in variable: do things with element