Các vòng lặp trong python là gì?

Video hướng dẫn này giải thích vai trò của Vòng lặp trong Python, các loại của chúng. For, While, Nested Loops với cú pháp và các ví dụ lập trình thực tế

Chúng ta đã học về bốn câu lệnh Điều kiện khác nhau trong Python trong hướng dẫn trước của mình

Vòng lặp là khái niệm lập trình mạnh mẽ được hỗ trợ bởi hầu hết các ngôn ngữ lập trình hiện đại. Nó cho phép một chương trình thực hiện các phép lặp, về cơ bản có nghĩa là thực thi cùng một khối mã hai lần trở lên

Mặc dù chúng được tất cả các ngôn ngữ lập trình hiện đại hỗ trợ và cung cấp chức năng cơ bản tương tự, nhưng cách triển khai và cú pháp của chúng có thể khác nhau

Chuỗi khóa đào tạo đầy đủ về Python sẽ cung cấp cho bạn ý tưởng ngắn gọn về Python là gì.

Bạn sẽ học được gì

Video hướng dẫn về vòng lặp Python

Vòng lặp Python là gì

Trong Python, các câu lệnh được thực thi một cách tuần tự. e. nếu mã của chúng tôi được tạo thành từ nhiều dòng mã, thì quá trình thực thi sẽ bắt đầu ở dòng đầu tiên, tiếp theo là dòng thứ hai, v.v.

Tuy nhiên, sẽ có trường hợp chúng ta muốn một khối mã thực thi nhiều lần cho đến khi thỏa mãn điều kiện. Nhờ các câu lệnh lặp, chúng ta có thể làm điều đó

Đưa ra dưới đây là một sơ đồ minh họa cách thức hoạt động của một câu lệnh lặp

Dựa vào sơ đồ trên, một chương trình Python sẽ bắt đầu tại Start[circle], và quá trình thực thi sẽ tiến hành tới câu lệnh điều kiện[Diamond], nếu điều kiện là TRUE thì chương trình sẽ thực thi khối mã

Quá trình thực thi sẽ tiếp tục trở lại câu lệnh điều kiện và quy trình tương tự tiếp tục mỗi khi điều kiện là ĐÚNG. Nó chỉ thoát ra khỏi vòng lặp hoặc dừng thực thi khối mã nếu điều kiện là SAI, và trong trường hợp này, chương trình sẽ tiếp tục thực hiện tuần tự

Python có hai loại Vòng lặp

#Loop typeDescription1for loopLà vòng lặp dựa trên trình vòng lặp, bước này duyệt qua các mục của đối tượng có thể lặp lại như danh sách, bộ dữ liệu, chuỗi và thực thi lặp lại một đoạn mã trong một số lần, dựa trên số lượng mục trong đối tượng có thể lặp lại đó. 2 vòng lặp while Thực hiện lặp đi lặp lại một khối câu lệnh miễn là điều kiện là ĐÚNG

Hai loại vòng lặp này có thể được sử dụng bên trong nhau để tạo ra các vòng lặp lồng nhau (sẽ nói thêm về điều này sau)

Sử dụng chung Vòng lặp Python

Trong Python, các vòng lặp có thể được sử dụng để giải các bài toán hay và phức tạp. Bạn có thể sẽ gặp phải các sự cố yêu cầu bạn lặp lại một hành động cho đến khi đáp ứng một điều kiện (vòng lặp while hoạt động tốt nhất ở đây) hoặc sự cố yêu cầu bạn thực hiện một hành động trên một loạt mục (vòng lặp for hoạt động tốt nhất ở đây)

Vòng lặp trong Python

Vòng lặp for hoạt động tốt với các đối tượng có thể lặp lại như danh sách, bộ dữ liệu, chuỗi, v.v. Bằng cách này, chúng tôi có thể duyệt qua các mục của đối tượng này và thao tác các giá trị của chúng dựa trên liên kết của chúng tôi

Vòng lặp for không được lập chỉ mục và có cú pháp sau

for in n:

Điều kiện trong vòng lặp for chỉ TRUE nếu nó không lặp qua tất cả các mục trong đối tượng có thể lặp lại (n). Để hiểu rõ hơn về vòng lặp for, chúng ta sẽ giải quyết một số ví dụ và cuối cùng, chúng ta sẽ làm việc với một ví dụ thực tế

Ví dụ 1. In số từ đầu đến cuối

Để đạt được điều này, chúng ta sẽ sử dụng hàm phạm vi Python

Đây là cách lưu đồ sẽ trông như thế nào

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

đầu ra

Trong ví dụ trên, chúng tôi đã sử dụng phạm vi Python, là hàm trả về một chuỗi số, bắt đầu từ số bắt đầu (0 theo mặc định), tăng dần theo một bước (1 theo mặc định) và dừng trước số kết thúc

Đối với ví dụ này , chúng tôi có những điều sau đây.

Tham số và giá trị cho hàm phạm vi Python

Tham sốValuestart1end20step1 (giá trị mặc định)

Vì vậy, vòng lặp for của chúng ta sẽ lặp qua một dãy số từ 1 đến 20 và với mỗi lần lặp, nó sẽ in ra số. Quá trình lặp dừng lại khi tất cả các số trong dãy đã được thăm

Ví dụ 2. Xác định xem một số có phải là số nguyên tố hay không.

Trong ví dụ này, chúng ta sẽ thấy tại sao vòng lặp for lại mạnh mẽ và hữu ích đến vậy. Ở đây, chúng tôi sẽ lặp qua một dãy số và với mỗi số, chúng tôi sẽ thực hiện một số tính toán để xác định xem một điều kiện là TRUE hay FALSE

Có thể hữu ích khi biết điều kiện để một số là số nguyên tố

• Số luôn dương, lớn hơn 1
• Không có ước dương nào ngoài 1 và chính nó

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

Đầu ra khi đầu vào là 13

Đầu ra khi đầu vào là 10

Ghi chú. If-else được sử dụng trong ví dụ trên là một câu lệnh có điều kiện và không phải là một vòng lặp. Nhưng cũng giống như vòng lặp while (mà chúng tôi sẽ trình bày sau đây), nó sử dụng các toán tử so sánh cho điều kiện của nó

Ví dụ – Tìm số từ trong văn bản bằng vòng lặp for

Ví dụ này nói về việc đếm số lần mỗi từ xuất hiện trong một văn bản. Có rất nhiều cách để đạt được điều này nhưng trong ví dụ này, chúng ta sẽ sử dụng vòng lặp for

Chúng ta sẽ đếm các từ trong văn bản dưới đây

Xin chào, chào mừng bạn đến với Trợ giúp kiểm thử phần mềm. trong bài báo này. “Vòng lặp trong Python”, bạn sẽ tìm hiểu về vòng lặp với các ví dụ thực tế. Tuyệt phải không?

Mã hóa vui vẻ

Điều đầu tiên chúng ta sẽ làm là xóa dấu chấm câu, khoảng trắng và tất cả các chữ cái viết thường. Chúng tôi sẽ xóa dấu câu theo cách truyền thống bằng cách xác định dấu câu nào tồn tại trong văn bản của chúng tôi, sau đó sử dụng vòng lặp for để thay thế chúng bằng một chuỗi trống

Vì văn bản không nhiều nên chúng tôi thấy các dấu câu là dấu phẩy (,), dấu chấm (. ), dấu hỏi (?), dấu hai chấm (. ), dấu ngoặc kép(“) và dấu nháy đơn(‘)

Đưa ra dưới đây là mã để thay thế chúng bằng một chuỗi rỗng. Lưu ý rằng chúng tôi sẽ không thay thế dấu nháy đơn

# replace punctuation(except apostrophe) and white spaces
    for punc in '.,\n?!"':
        text = text.replace(punc, '')
    # lowercase all letters.
    text = text.lower()

đầu ra

Tiếp theo, chúng ta sẽ chia văn bản thành một danh sách các từ được phân tách bằng khoảng trắng

# Split text into list of words separated by whitespaces(tab, newline)
text = text.split()

đầu ra

Cuối cùng, chúng ta sẽ đếm và xem mỗi từ xuất hiện bao nhiêu lần trong văn bản được chia

# initialize a dictionary to hold words:count
wordsCount = {} 
# if a word is already a key in our dictionary, increment it's value. 
# If not, initialize it's value to 1.
for word in text:
    wordsCount[word] = wordsCount.get(word, 0) + 1

đầu ra

Chúng ta có thể thấy rõ ràng một số từ xuất hiện hai lần và một số chỉ xuất hiện một lần. Hãy sắp xếp từ điển này theo giá trị của nó theo thứ tự giảm dần để chúng ta có thể phân biệt rõ ràng. Ở đây, chúng tôi đã sử dụng chức năng sắp xếp Python, và hiểu từ điển

# Sort dictionary by value, in descending order
wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item[1], reverse=True)}

Cuối cùng, chúng ta đã sử dụng vòng lặp for để dọn dẹp, đếm và sắp xếp các từ trong văn bản của mình

Đưa ra dưới đây là mã hoàn chỉnh

def word_count(text):
    # initialize a dictionary to hold words:count
    wordsCount = {} 
    # replace punctuation(except apostrophe) and white spaces
    for punc in '.,\n?!"':
        text = text.replace(punc, '')
    # lowercase all letters.
    text = text.lower()
    # Split text into list of words separated by whitespaces(tab, newline) and apostrophe(')
    text = text.split()

    # if a word is already a key in our dictionary, increment it's value. 
    # If not, initialize it's value to 1.
    for word in text:
            wordsCount[word] = wordsCount.get(word, 0) + 1

    # Sort dictionary by value, in descending order
    wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item[1], reverse=True)}

    print(wordsCount)


if __name__ == '__main__':
    text = "Hello, welcome to Software Testing Help. In this article: \"Loops in Python\", \
you'll learn about loops with practical examples. \
Great right? Make sure to follow along as we  learn together. \n \
Happy coding!"

    word_count(text)

Kết quả cuối cùng

Vòng lặp While

Vòng lặp while của Python thực thi lặp đi lặp lại một khối câu lệnh miễn là điều kiện là TRUE. Chúng tôi nhận thấy rằng nó hơi giống với câu lệnh if. Tuy nhiên, không giống như vòng lặp while, câu lệnh if chỉ thực hiện một lần nếu điều kiện của nó là TRUE

Vòng lặp while có cú pháp như sau

Không giống như vòng lặp for, vòng lặp while không lặp qua một chuỗi. Nó sử dụng các toán tử so sánh và boolean cho điều kiện của nó

Hãy xem xét một số ví dụ để hiểu rõ hơn về cách nó được sử dụng

Ví dụ 1. In “Xin chào thế giới. ” một số lần

Vòng lặp while kiểm tra điều kiện (đếm < n), mỗi khi nó ĐÚNG, nó sẽ in “Xin chào thế giới của chúng tôi. ” và tăng số đếm

Đây là cách lưu đồ sẽ trông như thế nào

def print_count_times(n):
    # set count to 0
    count = 0

    while count < n:
        print("Hello World!")
        # increment count
        count += 1

if __name__ == '__main__':
    # number of times we want to print 
    n = 10
    # call our function to print n times.
    print_count_times(n)

đầu ra

Ví dụ 2. Tìm giai thừa của một số

Giai thừa của một số được biểu diễn dưới dạng n. và nó có công thức

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

Chương trình kiểm tra nếu số đó là 0 và trả về 1 (giai thừa của 0 là 1). Sau đó, vòng lặp while kiểm tra điều kiện (n >=1) để xem n của chúng ta có bằng 1 hay lớn hơn 1 không. Mỗi khi điều kiện này là TRUE, chương trình của chúng tôi sẽ tính toán công thức trong khối vòng lặp

Hãy sử dụng vòng lặp while để giải bài toán giai thừa

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

đầu ra

Ví dụ – Tìm một dãy Fibonacci cho đến số hạng thứ n bằng vòng lặp While

Dãy Fibonacci có công thức

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

Hai số đầu tiên là 0 và 1, sau đó các số tiếp theo là tổng của hai số trước đó (n-1)th và (n-2)th

Dãy Fibonacci của 8 sẽ là 0,1,1,2,3,5,8,13

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

đầu ra

Trước tiên, chương trình của chúng tôi xác định giá trị thứ n đầu tiên (n1=0), sau đó chương trình sẽ kiểm tra xem n_term được truyền dưới dạng đối số có bằng 1 không. Nếu TRUE, nó trả về 0

Khác, nó xác định hai biến

• đếm = 0. Điều này sẽ được sử dụng trong vòng lặp while để kiểm tra điều kiện nếu số đếm nhỏ hơn n_term(count < n_term)
• n2=1. Đây là giá trị thứ n thứ hai của chúng tôi

Cho đến nay, chúng tôi có 0,1 trong chuỗi của chúng tôi (n1, n2). Trong khi điều kiện là TRUE

• Giá trị của n2 được gán cho một biến tạm thời(temp = n2)
• Tổng của hai số liền trước được tính và gán cho n2(n2 = n1 + n2)
• Giá trị tạm thời của chúng ta(n2 giá trị cũ) được gán cho n1(n1 = temp)
• Số lượng của chúng tôi được tăng lên (số lượng +=1) và điều kiện được kiểm tra lại

Vào cuối lần lặp đầu tiên, chúng ta có 0,1,1 trong đó

• n1 = 1 (1 đầu tiên)
• n2= 1 ( cái thứ hai 1)

Thao tác này sẽ lặp lại cho đến khi điều kiện count

Vòng lặp lồng nhau

Điều thú vị về các vòng lặp trong Python là chúng có thể được lồng vào nhau. e. chúng ta có thể sử dụng một hoặc nhiều vòng lặp bên trong một vòng lặp khác. Điều này cho phép chúng tôi giải quyết các vấn đề phức tạp hơn

#1) Làm tổ cho các vòng lặp

vòng lặp for có thể lồng vào nhau. Cú pháp bên dưới hiển thị vòng lặp for lồng nhau 1 cấp

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

Ví dụ 1. Sử dụng vòng lặp for lồng nhau để in số theo mẫu

Hãy sử dụng vòng lặp for lồng nhau để in mẫu sau

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

Mỗi số được in một số lần tương ứng với chính số đó

Đây là cách lưu đồ sẽ trông như thế nào

đầu ra

Chương trình của chúng tôi hoạt động như sau

• Vòng lặp bên ngoài lặp qua phạm vi từ 1 đến 6 và cho từng mục trong chuỗi đó
• Nó đi vào vòng lặp bên trong nơi nó lặp lại trên một phạm vi của mục đó
• Đối với mỗi lần lặp lại của mục đó, nó sẽ in mục đó
• Nó chỉ rời khỏi vòng lặp bên trong khi nó đã lặp hoàn toàn qua một phạm vi của mục đó
• Khi nó rời khỏi vòng lặp bên trong, nó quay trở lại vòng lặp bên ngoài và quá trình tiếp tục cho đến khi nó lặp hoàn toàn chuỗi của nó

Ví dụ 2. Thao tác với các mục của danh sách lồng nhau bằng cách sử dụng vòng lặp for lồng nhau

Một tình huống chúng ta có thể gặp trong Python là truy cập các mục của danh sách lồng nhau

Ví dụ: lấy danh sách lồng nhau bên dưới

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

Đối với ví dụ này, hãy viết một chương trình sẽ đếm số lượng số nguyên và số thực trong danh sách lồng nhau này.

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

đầu ra

Chương trình của chúng tôi hoạt động theo cách này

• Vòng lặp bên ngoài truy cập danh sách bên trong đầu tiên [3,4. 0,2,8. 4,6] trong danh sách lồng nhau của chúng tôi
• Vòng lặp bên trong truy cập từng mục trong danh sách bên trong đầu tiên này. Đối với mỗi mục, nó sẽ kiểm tra xem đó là số float hay số nguyên. Nếu nó là một số nguyên, nó sẽ tăng số lượng số nguyên (int_count). Khác nếu đó là số float, nó sẽ tăng số float (float_count)
• Khi nó đã hoàn thành việc lặp qua danh sách bên trong đầu tiên này, nó sẽ quay trở lại vòng lặp bên ngoài và truy cập danh sách thứ hai [0,2,0. 2,4,6] và quá trình tương tự tiếp tục cho đến khi nó truy cập được tất cả các danh sách bên trong

#2) Các vòng lặp While lồng vào nhau

Trong khi các vòng lặp có thể được lồng trong chính chúng

Cú pháp bên dưới hiển thị vòng lặp while lồng nhau 1 cấp

def range_from_start_to_end(start, end):

    for i in range(start, end+1):
        print(i)

if __name__ == "__main__":
    start = int(input("Enter a start number: "))
    end = int(input("Enter an end number: "))
    # Call our function to print the ranges
    range_from_1_to_20(start, end)

Ví dụ 3. Sử dụng vòng lặp while lồng nhau để in sao(*) theo mẫu

Hãy sử dụng vòng lặp while lồng nhau để xây dựng mẫu sau

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

đầu ra

Chương trình của chúng tôi hoạt động như sau

• Các biến được khởi tạo (i=0, j=0, n=5)
• Vòng lặp bên ngoài của chúng tôi kiểm tra điều kiện (0 <= 5) rõ ràng là ĐÚNG
• Vòng lặp bên trong của chúng tôi kiểm tra điều kiện (0 < 0) rõ ràng là SAI, vì vậy chương trình của chúng tôi thoát ra khỏi vòng lặp bên trong
• i được tăng lên và vòng lặp bên ngoài kiểm tra lại điều kiện của nó (1 <= 5) là TRUE
• Vòng lặp bên trong của chúng tôi kiểm tra điều kiện (0 < 1) là TRUE. Vì vậy, một dấu sao(*) được in ra và j được tăng lên và điều kiện vòng lặp bên trong được kiểm tra với (1 < 1) là SAI, do đó thoát ra khỏi vòng lặp bên trong

Quá trình trên tiếp tục cho đến khi điều kiện vòng lặp bên ngoài trở thành FALSE

Ví dụ – Trò chơi đánh vần số

Để hoàn thiện vòng lặp lồng nhau, chúng ta sẽ xây dựng một trò chơi thú vị giúp đánh giá khả năng nhận biết và đánh vần các con số của trẻ

Chương trình hiển thị các số ngẫu nhiên trên màn hình và yêu cầu đánh vần số đó. Nó kiểm tra nếu nhập đúng thì nó hiện số khác. Nếu nhập sai, nó sẽ gửi thông báo lỗi và yêu cầu câu trả lời khác

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

đầu ra

Các chức năng chính của vòng lặp for và vòng lặp while của chúng tôi là

• Vòng lặp for lặp qua danh sách các số được hiển thị cho người dùng để đánh vần
• Vòng lặp while kiểm tra xem số lượng thử nghiệm đã bị vượt quá chưa. Theo cách này, người dùng được cung cấp số lần dùng thử tối đa để làm đúng

Chúng tôi đã thấy hai khái niệm mới trong khi khác, phá vỡ (thêm về điều này sau). Vòng lặp while và vòng lặp for ban đầu có một câu lệnh khác chỉ thực hiện một lần khi điều kiện là SAI

Vòng lặp vô hạn Python

Nếu chúng ta không cẩn thận với cách chúng ta thực hiện các vòng lặp của mình, thì nó có thể dẫn đến một vòng lặp vô hạn i. e. chương trình sẽ thực thi mãi mãi một khối mã cho đến khi máy tính của chúng ta hết tài nguyên như bộ nhớ CPU

Ví dụ 1. Vòng lặp while vô tận

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

đầu ra

Ghi chú. Để dừng chạy chương trình này, hãy sử dụng Ctrl+z hoặc Ctrl+c trên thiết bị đầu cuối mà bạn đã sử dụng để chạy mã

Đoạn mã trên của chúng ta thực hiện một vòng lặp while vô hạn. Tuy nhiên, điều này là do nhầm lẫn vì vòng lặp while của chúng ta kiểm tra điều kiện tê < 5, nhưng không có chỗ nào trong mã thực sự làm tăng giá trị của tê. Do đó, giá trị của tê luôn bằng 0 và điều kiện tiếp tục trả về TRUE

Vì vậy, cách để khắc phục điều này là cung cấp một phương tiện để tăng giá trị của tê liệt

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

đầu ra

Một câu hỏi có thể nảy sinh là vòng lặp vô hạn có thực sự cần thiết? . vâng họ là. Một máy chủ có thể được lập trình để chạy liên tục trong khi phục vụ nhu cầu của khách hàng. Khi chơi trò chơi, một sự kiện có thể chạy cho đến khi người dùng chọn một hành động để thoát hoặc ngắt vòng lặp

Dù bạn có tin hay không thì tùy, chúng tôi thực sự đã sử dụng một vòng lặp vô hạn trong ví dụ thực tế cuối cùng ở trên. Vì vậy, làm thế nào để chúng ta đối phó với các vòng lặp vô hạn?

Các câu lệnh ngắt và tiếp tục trong Python

Như chúng tôi đã giải thích ở trên, có những trường hợp chúng tôi sẽ cần viết các vòng lặp vô hạn có chủ ý. Trong những trường hợp này, chúng ta sẽ thấy rằng các từ khóa break và continue là xương sống của các vòng lặp vô hạn

Các từ khóa break và continue thường được sử dụng trong câu lệnh if của Python trong đó câu lệnh if kiểm tra một điều kiện và nếu nó ĐÚNG, chúng ta sẽ thoát ra khỏi vòng lặp mà câu lệnh if của chúng ta được gọi hoặc tiếp tục bằng cách bỏ qua tất cả mã bên dưới nó và quay lại

Ví dụ – Tích lũy số cho đến khi đạt đến ngưỡng

Hãy xem xét một chương trình lấy số từ một nguồn được tạo ngẫu nhiên và tích lũy các số cho đến khi đạt đến ngưỡng

Lý do tại sao ví dụ này yêu cầu một vòng lặp vô hạn là vì chúng ta không biết chính xác chương trình của chúng ta sẽ cần thực hiện bao nhiêu lần lặp để các số tích lũy đạt đến ngưỡng

Vị cứu tinh duy nhất của chúng ta là câu lệnh if của Python cùng với câu lệnh break. Câu lệnh if của chúng ta kiểm tra xem đã đạt đến ngưỡng chưa, sau đó nó thoát ra khỏi vòng lặp nếu TRUE

Chương trình của chúng tôi cũng yêu cầu không được tích lũy một số số bị hạn chế. Vì vậy, nếu chương trình của chúng tôi gặp những con số này, nó sẽ bỏ qua tất cả các mã và quay lại đầu vòng lặp. Điều này có thể đạt được với câu lệnh continue

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

đầu ra

Các câu hỏi thường gặp

Q #1) Làm cách nào để bạn kiểm soát Vòng lặp trong Python?

Trả lời. Trong Python, bạn có thể điều khiển một vòng lặp bằng các câu lệnh điều khiển sau

• Từ khóa break thoát ra khỏi vòng lặp
• Từ khóa continue bỏ qua tất cả các mã bên dưới nó và quay lại đầu vòng lặp

Những từ khóa này chủ yếu được sử dụng trong câu lệnh if trước tiên kiểm tra xem một điều kiện là TRUE hay FALSE

Q #2) Sự khác biệt giữa vòng lặp for và vòng lặp while là gì?

Trả lời. Vòng lặp for là một vòng lặp dựa trên trình vòng lặp, bước này duyệt qua các mục của các đối tượng có thể lặp lại như danh sách, bộ dữ liệu, v.v. Trong khi vòng lặp while là vòng lặp dựa trên điều kiện, vòng lặp này thực thi lặp đi lặp lại một khối câu lệnh miễn là điều kiện của nó là ĐÚNG

Q #3) Python có hỗ trợ vòng lặp until không?

Trả lời. Thật không may, Python không hỗ trợ vòng lặp do-while

Q #4) Hai loại vòng lặp trong Python là gì?

Trả lời. Python thường hỗ trợ hai loại vòng lặp. vòng lặp for và vòng lặp while. Tuy nhiên, vòng lặp thứ ba[vòng lặp lồng nhau] có thể được tạo bằng cách lồng hai hoặc nhiều vòng lặp này vào nhau

Tìm hiểu thêm về vòng lặp Python

Các câu lệnh lặp trong python được sử dụng để thực thi một khối câu lệnh hoặc mã lặp đi lặp lại nhiều lần theo chỉ định của người dùng

Python cung cấp cho chúng ta 2 loại vòng lặp như bên dưới

• Trong khi lặp lại
• cho vòng lặp

#1) Vòng lặp While

Vòng lặp while trong python được sử dụng để thực thi nhiều câu lệnh hoặc mã lặp đi lặp lại cho đến khi điều kiện đã cho là đúng

Chúng tôi sử dụng vòng lặp while khi chúng tôi không biết số lần lặp lại

cú pháp

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

Trong vòng lặp while ta kiểm tra biểu thức, nếu biểu thức đúng thì khối câu lệnh có trong vòng lặp while mới được thực thi. Với mỗi lần lặp, nó sẽ kiểm tra điều kiện và thực hiện khối câu lệnh cho đến khi điều kiện trở thành sai

Ví dụ

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

đầu ra

10

đầu ra

#2) Đối với vòng lặp

Vòng lặp for trong python được sử dụng để thực thi một khối câu lệnh hoặc mã nhiều lần cho đến khi điều kiện đã cho trở thành sai

Chúng ta sử dụng vòng lặp for khi biết số lần lặp

cú pháp

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

Ở đây var sẽ lấy giá trị từ dãy và thực hiện nó cho đến khi thực hiện xong tất cả các giá trị trong dãy

Ví dụ

def isPrime(number):
    # rule 1: number should be positive, and greater than 1.
    if number > 1:
        # iterate over a range from 2 to half the number.
        for i in range(2, number//2):
            # rule 2: shouldn't have any positive divisor 
            # order than 1 and itself.
            if(number % i) ==0:
                return False
        
        return True
    else:
        return False

if __name__ == '__main__':
    number = int(input("Enter number to check if it's prime: "))

    if isPrime(number):
        print("{} is a prime number".format(number))
    else:
        print("{} is not a prime number".format(number))

đầu ra

ngôn ngữ hiện tại là. con trăn

ngôn ngữ hiện tại là. Java

ngôn ngữ hiện tại là. hồng ngọc

đầu ra

Đối với vòng lặp sử dụng hàm range()

Hàm Range() dùng để tạo ra một dãy số

Ví dụ , dãy (5) sẽ tạo ra các số từ 0 đến 4 (5 số).

Ví dụ

# replace punctuation(except apostrophe) and white spaces
    for punc in '.,\n?!"':
        text = text.replace(punc, '')
    # lowercase all letters.
    text = text.lower()

đầu ra

ngôn ngữ hiện tại là. con trăn

ngôn ngữ hiện tại là. Java

ngôn ngữ hiện tại là. hồng ngọc

đầu ra

Phần kết luận

Trong hướng dẫn này, chúng ta đã thấy định nghĩa về vòng lặp, các loại vòng lặp Python, cách sử dụng vòng lặp for và vòng lặp while với một số ví dụ

Chúng tôi cũng đã học cách tạo ra các vòng lặp lồng nhau cũng như các vòng lặp hữu hạn và chúng tôi đã biết cách sử dụng các từ khóa ngắt và tiếp tục

3 loại vòng lặp là gì?

4 loại vòng lặp là gì?

Các loại vòng lặp trong Python là gì?

Vòng lặp với Ví dụ trong Python là gì?