programming python

Đệ quy với chuỗi Python

Một ví dụ về thế giới vật chất sẽ là đặt hai gương song song đối diện nhau. Bất kỳ đối tượng nào ở giữa chúng sẽ được phản ánh đệ quy

Hàm đệ quy Python

Trong Python, chúng ta biết rằng một hàm có thể gọi các hàm khác. Hàm thậm chí có thể gọi chính nó. Các loại cấu trúc này được gọi là hàm đệ quy

Hình ảnh sau đây cho thấy hoạt động của một hàm đệ quy có tên là

reverseString["code"]

# Output
'edoc'

Hàm đệ quy trong Python

Sau đây là một ví dụ về hàm đệ quy để tìm giai thừa của một số nguyên

Giai thừa của một số là tích của tất cả các số nguyên từ 1 đến số đó. Ví dụ, giai thừa của 6 [ký hiệu là 6. ] là 1*2*3*4*5*6 = 720

Ví dụ về hàm đệ quy

def factorial[x]:
    """This is a recursive function
    to find the factorial of an integer"""

    if x == 1:
        return 1
    else:
        return [x * factorial[x-1]]


num = 3
print["The factorial of", num, "is", factorial[num]]

đầu ra

The factorial of 3 is 6

Trong ví dụ trên,

reverseString["code"]

# Output
'edoc'

1 là một hàm đệ quy vì nó gọi chính nó

Khi ta gọi hàm này với số nguyên dương thì nó sẽ gọi đệ quy chính nó bằng cách giảm số

Mỗi hàm nhân một số với giai thừa của số bên dưới nó cho đến khi nó bằng một. Cuộc gọi đệ quy này có thể được giải thích trong các bước sau

factorial[3]          # 1st call with 3
3 * factorial[2]      # 2nd call with 2
3 * 2 * factorial[1]  # 3rd call with 1
3 * 2 * 1             # return from 3rd call as number=1
3 * 2                 # return from 2nd call
6                     # return from 1st call

Hãy xem một hình ảnh thể hiện quy trình từng bước về những gì đang diễn ra

Làm việc của hàm giai thừa đệ quy

Đệ quy của chúng tôi kết thúc khi số lượng giảm xuống 1. Đây được gọi là điều kiện cơ bản

Mỗi hàm đệ quy phải có một điều kiện cơ bản để dừng đệ quy, nếu không thì hàm sẽ tự gọi nó vô hạn

Trình thông dịch Python giới hạn độ sâu của đệ quy để giúp tránh các đệ quy vô hạn, dẫn đến tràn ngăn xếp

Theo mặc định, độ sâu đệ quy tối đa là 1000. Nếu giới hạn bị vượt qua, kết quả là

reverseString["code"]

# Output
'edoc'

2. Hãy xem xét một điều kiện như vậy

Khi bạn đang làm việc với các chuỗi Python, đôi khi bạn sẽ phải đảo ngược chúng và thay vào đó làm việc với các bản sao đã đảo ngược của chúng

Nhưng vì các chuỗi Python là bất biến nên bạn không thể sửa đổi hoặc đảo ngược chúng tại chỗ

Trong Python, có một số cách khác nhau để bạn có thể thực hiện việc này. Và hướng dẫn này sẽ dạy bạn cách bạn có thể sử dụng kỹ thuật cắt chuỗi, các phương thức tích hợp sẵn và đệ quy để đảo ngược chuỗi

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

Bạn sẽ tìm hiểu về cách thức hoạt động của đệ quy và trực giác đằng sau việc đảo ngược các chuỗi bằng cách sử dụng đệ quy
Bạn sẽ học một cách dễ dàng hơn nhiều để đảo ngược chuỗi Python
Bạn sẽ học một cách dễ dàng và trực quan khác để đảo ngược chuỗi trong Python

Vậy hãy bắt đầu

Cách đảo ngược chuỗi Python bằng đệ quy

Trước khi tìm hiểu cách sử dụng đệ quy để đảo ngược chuỗi, hãy bắt đầu bằng cách tìm hiểu cách thức hoạt động của đệ quy

Đệ quy là một mô hình lập trình mạnh mẽ. Để giải quyết vấn đề quan tâm, một hàm đệ quy gọi chính nó nhiều lần, cho đến khi đạt được trường hợp cơ sở

Chà, đây là những gì bạn có thể đã đọc về đệ quy trước đây

Bây giờ hãy viết lại định nghĩa đó bằng ngôn ngữ đơn giản

Đệ quy bằng tiếng Anh đơn giản

Giả sử bạn đã tạo một chức năng để giải quyết vấn đề

Chức năng được thiết kế sao cho mỗi khi nó được gọi, nó sẽ tự gọi lại
Chúng được gọi là các lệnh gọi hàm đệ quy
Mỗi lệnh gọi hàm đệ quy thực hiện cùng một lượng nhỏ công việc
Và điều này tiếp tục cho đến khi không còn việc gì để làm. Và chức năng không phải gọi chính nó nữa – đây được gọi là trường hợp cơ sở

Cách sử dụng đệ quy để đảo ngược chuỗi

Bây giờ chúng ta hãy thảo luận về động lực đằng sau việc đảo ngược chuỗi một cách trực quan. Và để làm điều này, hãy xem xét chuỗi

reverseString["code"]

# Output
'edoc'

Vấn đề. Đảo ngược chuỗi

reverseString["code"]

# Output
'edoc'

Hãy tạm quên đệ quy trong một thời gian và bắt đầu với những gì bạn biết

Chữ cái đầu tiên trong chuỗi ban đầu sẽ là chữ cái cuối cùng trong chuỗi đảo ngược, phải không?

Vì vậy, hãy rút ra chữ cái đầu tiên –
```
reverseString["code"]

# Output
'edoc'
```
1 ở đây – và đẩy nó đến cuối cùng
Bây giờ bạn còn lại chuỗi
```
reverseString["code"]

# Output
'edoc'
```
2. Và vấn đề đã giảm xuống để đảo ngược chuỗi con
```
reverseString["code"]

# Output
'edoc'
```
2 này [vì
```
reverseString["code"]

# Output
'edoc'
```
1 đã ở đúng vị trí]

Bạn có thể thực hiện lại nhiệm vụ tương tự là rút ra chữ cái đầu tiên một lần nữa, bây giờ
```
reverseString["code"]

# Output
'edoc'
```
5. Và đẩy nó vào khe cuối cùng có sẵn bên phải

Bây giờ thì

reverseString["code"]

# Output
'edoc'

1 và

reverseString["code"]

# Output
'edoc'

5 đã được xử lý xong, bạn chỉ còn lại vấn đề đảo ngược chuỗi con

reverseString["code"]

# Output
'edoc'

Thực hiện thêm vài lần nữa – rút
```
reverseString["code"]

# Output
'edoc'
```
9 ra trước, sau đó là
```
The factorial of 3 is 6
```
20

Bây giờ bạn chỉ còn lại việc đảo ngược
```
The factorial of 3 is 6
```
21 – một chuỗi rỗng

Đây là khi bạn đã đặt
```
The factorial of 3 is 6
```
20,
```
reverseString["code"]

# Output
'edoc'
```
9,
```
reverseString["code"]

# Output
'edoc'
```
5 và
```
reverseString["code"]

# Output
'edoc'
```
1 vào đúng vị trí và bạn không cần phải làm điều đó nữa. Trong bối cảnh đệ quy, bạn đã đạt đến trường hợp cơ bản

Bạn đã làm gì ở đây?

Trong mỗi bước, bạn thực hiện cùng một nhiệm vụ là rút ra chữ cái đầu tiên trong mỗi chuỗi con tiếp theo
Và bạn đã giảm vấn đề để đảo ngược một chuỗi ngắn hơn một chữ cái so với trước đây

Khi nào bạn dừng lại?

Khi chuỗi rỗng – bạn không còn ký tự nào để lấy ra

Hình minh họa bên dưới tóm tắt những gì chúng tôi đã làm

Trực giác đằng sau sự đảo ngược chuỗi [Hình ảnh của tác giả]

Bây giờ bạn đã hiểu rõ về cách đảo ngược chuỗi thực sự hoạt động bằng cách sử dụng đệ quy, hãy viết một số mã

Hiểu ngăn xếp cuộc gọi đệ quy

Đây là hàm Python

The factorial of 3 is 6

26 thực hiện chính xác những gì bạn đã học trong phần trước

Hàm

The factorial of 3 is 6

26 nhận vào

The factorial of 3 is 6

28 và trả về bản sao đảo ngược của

The factorial of 3 is 6

factorial[3]          # 1st call with 3
3 * factorial[2]      # 2nd call with 2
3 * 2 * factorial[1]  # 3rd call with 1
3 * 2 * 1             # return from 3rd call as number=1
3 * 2                 # return from 2nd call
6                     # return from 1st call

Bạn sẽ phải hiểu cách gọi hàm đệ quy được đẩy lên ngăn xếp khi bạn gọi hàm

The factorial of 3 is 6

reverseString["code"]

# Output
'edoc'

Giả sử, bạn gọi hàm
```
The factorial of 3 is 6
```
26 với đối số là
```
reverseString["code"]

# Output
'edoc'
```
3. Điều này lần lượt thực hiện một cuộc gọi tới
```
The factorial of 3 is 6
```
26 với
```
reverseString["code"]

# Output
'edoc'
```
2 làm đối số
Và cuộc gọi này thực hiện cuộc gọi đến
```
The factorial of 3 is 6
```
26 một lần nữa với _____38 làm đối số
Điều này tiếp tục cho đến khi một cuộc gọi cuối cùng được thực hiện tới
```
The factorial of 3 is 6
```
26 với một chuỗi rỗng
```
The factorial of 3 is 6
```
21 làm đối số

Đối với mỗi lệnh gọi hàm, một bản ghi kích hoạt sẽ được tạo trong phần ngăn xếp của bộ nhớ máy tính của bạn.

Và bản ghi kích hoạt của mọi lệnh gọi chức năng tiếp theo được đẩy lên trên cùng của ngăn xếp.

Điều này được giải thích trong hình dưới đây

Call Stack [Ảnh của tác giả]

Bạn biết rằng khi cuộc gọi được thực hiện với
```
The factorial of 3 is 6
```
21, hàm trả về
```
The factorial of 3 is 6
```
21 được nối với
```
The factorial of 3 is 6
```
20 chỉ là
```
The factorial of 3 is 6
```
20. Và bản ghi kích hoạt của nó được bật ra khỏi ngăn xếp
Cuộc gọi tiếp theo trả về
```
reverseString["code"]

# Output
'edoc'
```
63 và cuộc gọi tiếp theo trả về
```
reverseString["code"]

# Output
'edoc'
```
64. Và bản ghi kích hoạt bật ra khỏi ngăn xếp cuối cùng trả về
```
reverseString["code"]

# Output
'edoc'
```
65 là chuỗi đảo ngược

Lưu ý rằng bản ghi kích hoạt tương ứng với từng lệnh gọi đệ quy sẽ được bật ra khỏi ngăn xếp sau khi các giá trị được trả về – như được hiển thị trong lệnh gọi trả về

The factorial of 3 is 6

Để dễ đọc, tôi đã bỏ qua ❌ trong hình minh họa bên dưới. Và các giá trị trả về từ cuộc gọi trước đó đã được biểu thị bằng màu xanh lá cây bên trong ngăn xếp cuộc gọi

Trả về các giá trị từ các cuộc gọi đệ quy [Hình ảnh của tác giả]

Bây giờ bạn có thể gọi

The factorial of 3 is 6

26 bằng bất kỳ chuỗi Python hợp lệ nào. Dưới đây là một vài ví dụ khác

The factorial of 3 is 6

reverseString["code"]

# Output
'edoc'

Chà, điều đó đòi hỏi khá nhiều nỗ lực. 😓 Nhưng tôi hy vọng bây giờ bạn có thể hiểu các cuộc gọi đệ quy tốt hơn. 😊

Trong hai phần tiếp theo, bạn sẽ thấy các cách đảo ngược chuỗi dễ dàng hơn. Đi nào. ✅

Cách đảo ngược chuỗi Python bằng cách cắt chuỗi

Bạn cũng có thể đảo ngược chuỗi Python bằng cách cắt chuỗi. Và bạn có thể cắt qua các chuỗi Python giống như cách bạn cắt qua các danh sách Python

Giải thích về việc cắt chuỗi Python

reverseString["code"]

# Output
'edoc'

68 trả về một lát của chuỗi – bắt đầu từ chỉ mục

reverseString["code"]

# Output
'edoc'

69, kéo dài đến tận

reverseString["code"]

# Output
'edoc'

50, theo các bước của

reverseString["code"]

# Output
'edoc'

Dưới đây là một vài điểm về chuỗi đáng nhớ

```
reverseString["code"]

# Output
'edoc'
```
52 là bất kỳ chuỗi Python hợp lệ nào
Chỉ mục
```
reverseString["code"]

# Output
'edoc'
```
69 là tùy chọn. Nếu bạn không chỉ định nó, theo mặc định, lát cắt sẽ bắt đầu ở đầu
```
reverseString["code"]

# Output
'edoc'
```
52 [tại chỉ mục
```
reverseString["code"]

# Output
'edoc'
```
55]
Chỉ mục
```
reverseString["code"]

# Output
'edoc'
```
56 cũng là tùy chọn. Nếu bạn không chỉ định nó, theo mặc định, lát cắt sẽ kéo dài đến hết
```
reverseString["code"]

# Output
'edoc'
```
52
Đối số
```
reverseString["code"]

# Output
'edoc'
```
51 tùy chọn cung cấp ngữ cảnh về cách bạn muốn cắt qua
```
reverseString["code"]

# Output
'edoc'
```
52
Hãy đặt
```
reverseString["code"]

# Output
'edoc'
```
50. Bây giờ, lát cắt sẽ bắt đầu từ
```
reverseString["code"]

# Output
'edoc'
```
69 và đi đến
```
reverseString["code"]

# Output
'edoc'
```
50 , bao gồm mọi ký tự thứ hai trong chuỗi

Đặt tất cả lại với nhau,

reverseString["code"]

# Output
'edoc'

53 trả về một bản sao của toàn bộ chuỗi

Bạn có thể thấy tại sao điều này là chính xác?🤔

Không có chỉ số

reverseString["code"]

# Output
'edoc'

69, lát bắt đầu tại chỉ số

reverseString["code"]

# Output
'edoc'

Không có chỉ mục

reverseString["code"]

# Output
'edoc'

56, lát cắt sẽ mở rộng đến ký tự cuối cùng trong chuỗi

Không có đối số

reverseString["code"]

# Output
'edoc'

51, lát cắt bao gồm tất cả các ký tự trong chuỗi

Bạn cũng có thể đặt giá trị âm cho
```
reverseString["code"]

# Output
'edoc'
```
51. Và các giá trị âm sẽ trả về các lát chuỗi bắt đầu từ cuối chuỗi
Đặt
```
reverseString["code"]

# Output
'edoc'
```
59. Điều này trả về một lát của chuỗi bắt đầu từ ký tự cuối cùng, kéo dài đến ký tự đầu tiên. Và nó cũng bao gồm mọi ký tự

Đợi đã, đây không phải chính xác là chuỗi đảo ngược sao?

Vì vậy,

reverseString["code"]

# Output
'edoc'

50 trả về một bản sao đảo ngược của chuỗi. ✅

reverseString["code"]

# Output
'edoc'

Chuyển sang phần tiếp theo để tìm hiểu một cách khác để đảo ngược chuỗi

Cách đảo ngược chuỗi Python bằng phương thức

reverseString["code"]

# Output
'edoc'

51 và

reverseString["code"]

# Output
'edoc'

Hãy bắt đầu bằng cách xem phương thức

reverseString["code"]

# Output
'edoc'

51 của Python làm gì

Hàm
reverseString["code"]

# Output
'edoc'
51 tích hợp sẵn của Python trả về một trình vòng lặp đảo ngược trên các giá trị của một chuỗi đã cho

reverseString["code"]

# Output
'edoc'

Cho một chuỗi như

The factorial of 3 is 6

28, bạn có thể sử dụng phương thức

reverseString["code"]

# Output
'edoc'

51 để lấy các ký tự theo thứ tự đảo ngược

Điều này được hiển thị dưới đây

reverseString["code"]

# Output
'edoc'

Bây giờ bạn có tất cả các ký tự theo thứ tự đảo ngược, bạn cần đặt chúng lại với nhau thành một chuỗi.

Và phương thức

reverseString["code"]

# Output
'edoc'

52 của Python cho phép bạn làm điều đó

reverseString["code"]

# Output
'edoc'

58 nối

reverseString["code"]

# Output
'edoc'

59 thành một chuỗi với

reverseString["code"]

# Output
'edoc'

80 là dấu phân cách

Ở đây,
```
reverseString["code"]

# Output
'edoc'
```
59 là các ký tự theo thứ tự đảo ngược
Nhưng
```
reverseString["code"]

# Output
'edoc'
```
80 nên là gì?
Vậy bạn nên làm gì sau đó?

reverseString["code"]

# Output
'edoc'

Chỉ cần cẩn thận không chèn khoảng trắng giữa phần mở đầu và phần kết thúc

reverseString["code"]

# Output
'edoc'

85.

Nếu bạn làm như sau

reverseString["code"]

# Output
'edoc'

Bạn sẽ nhận được một chuỗi trong đó các ký tự được phân tách bằng khoảng trắng và đây không phải là điều bạn muốn

Trong phần này, bạn đã học được một cách Pythonic khác để đảo ngược chuỗi Python

Phần kết luận

Chúc mừng bạn đã tiến xa đến mức này. 🎉

Tóm lại, bạn đã học

cách đảo ngược đệ quy một chuỗi – tiếp tục cho đến khi bạn có một chuỗi trống hoặc chỉ còn lại một ký tự [điều này cũng hoạt động tốt, vì một ký tự bị đảo ngược chính là chính nó],

cách sử dụng

reverseString["code"]

# Output
'edoc'

50 để nhận bản sao đảo ngược của

reverseString["code"]

# Output
'edoc'

52 và

cách sử dụng

reverseString["code"]

# Output
'edoc'

88 để lấy bản sao đảo ngược của

reverseString["code"]

# Output
'edoc'

Hy vọng bạn thấy hướng dẫn này hữu ích và thú vị. Mã hóa vui vẻ. 😄

QUẢNG CÁO

Bala Priya C

Tôi là một nhà phát triển và nhà văn kỹ thuật đến từ Ấn Độ. Tôi viết hướng dẫn về mọi thứ liên quan đến lập trình và máy học

Nếu bạn đọc đến đây, hãy tweet cho tác giả để cho họ thấy bạn quan tâm. Tweet một lời cảm ơn

Học cách viết mã miễn phí. Chương trình giảng dạy mã nguồn mở của freeCodeCamp đã giúp hơn 40.000 người có được việc làm với tư cách là nhà phát triển. Bắt đầu

Đệ quy trong chuỗi là gì?

Đệ quy trong Java là một quá trình trong đó một phương thức gọi chính nó liên tục . Trong ngôn ngữ lập trình, nếu một chương trình cho phép chúng ta gọi một hàm bên trong cùng một tên hàm thì đó được gọi là cách gọi hàm đệ quy. Nó làm cho code nhỏ gọn nhưng rất khó hiểu.

Reverse[] trong Python là gì?

Python đảo ngược[] . computes the reverse of a given sequence object and returns it in the form of a list.

Làm thế nào để đảo ngược một chuỗi?

Bằng cách Sử dụng StringBuilder . Phương pháp này thay thế chuỗi ký tự theo thứ tự ngược lại. Phương thức đảo ngược là phương thức tĩnh có logic để đảo ngược chuỗi trong Java. StringBuilder or StringBuffer class has an in-build method reverse[] to reverse the characters in the string. This method replaces the sequence of the characters in reverse order. The reverse method is the static method that has the logic to reverse a string in Java.

Làm cách nào để đảo ngược các từ trong một câu chuỗi đã cho trong Python?

Dưới đây là các bước cần thực hiện để giải quyết vấn đề này. .

Tách từng từ trong một chuỗi đã cho bằng cách sử dụng phương thức split[] của kiểu dữ liệu chuỗi trong python

Đảo ngược danh sách tách từ

In các từ trong danh sách, ở dạng chuỗi sau khi nối từng từ với dấu cách bằng cách sử dụng ” “. phương thức tham gia [] trong python