Làm cách nào để phân vùng trong python?

Tôi cần giải một bài toán tương tự, đó là phép chia của một số nguyên

# Split the string on 'and'
S = 'Do it now and keep it simple'
x = S.partition['and']
print[x]
# Prints ['Do it now ', 'and', ' keep it simple']

0 thành các phần không âm của

# Split the string on 'and'
S = 'Do it now and keep it simple'
x = S.partition['and']
print[x]
# Prints ['Do it now ', 'and', ' keep it simple']

1, với các hoán vị. Đối với điều này, có một giải pháp đệ quy đơn giản [xem tại đây]

def partition[n, d, depth=0]:
    if d == depth:
        return [[]]
    return [
        item + [i]
        for i in range[n+1]
        for item in partition[n-i, d, depth=depth+1]
        ]


# extend with n-sum[entries]
n = 5
d = 3
lst = [[n-sum[p]] + p for p in partition[n, d-1]]

print[lst]

đầu ra

[
    [5, 0, 0], [4, 1, 0], [3, 2, 0], [2, 3, 0], [1, 4, 0],
    [0, 5, 0], [4, 0, 1], [3, 1, 1], [2, 2, 1], [1, 3, 1],
    [0, 4, 1], [3, 0, 2], [2, 1, 2], [1, 2, 2], [0, 3, 2],
    [2, 0, 3], [1, 1, 3], [0, 2, 3], [1, 0, 4], [0, 1, 4],
    [0, 0, 5]
]

Tách chuỗi thành một bộ ba phần

Cách sử dụng

Phương thức

# Split the string on 'and'
S = 'Do it now and keep it simple'
x = S.partition['and']
print[x]
# Prints ['Do it now ', 'and', ' keep it simple']

2 tách chuỗi ở lần xuất hiện đầu tiên của dấu phân cách và trả về một bộ chứa ba mục.

• Phần trước dải phân cách
• Bản thân dải phân cách
• Phần sau dải phân cách

phân vùng [] so với phân vùng []

Không giống như phân vùng [], Phương thức rpartition [] phân tách chuỗi ở lần xuất hiện cuối cùng của dấu tách

Mặt khác, cả hai phương pháp đều hoạt động giống hệt nhau

cú pháp

chuỗi. phân vùng [ dấu phân cách ]

Các tham số phương thức phân vùng chuỗi Python[] Tham sốĐiều kiệnMô tảBắt buộcYêu cầuBất kỳ chuỗi con nào để phân chia sting với

Ví dụ cơ bản

# Split the string on 'and'
S = 'Do it now and keep it simple'
x = S.partition['and']
print[x]
# Prints ['Do it now ', 'and', ' keep it simple']

Không tìm thấy kết quả phù hợp

Nếu không tìm thấy dấu phân cách , thì phương thức này trả về một bộ chứa chính chuỗi đó, theo sau là hai chuỗi trống.

S = 'Do it now and keep it simple'
x = S.partition['or']
print[x]
# Prints ['Do it now and keep it simple', '', '']

Nhiều trận đấu

Nếu dấu phân cách xuất hiện nhiều lần, thì phương thức này sẽ phân tách chuỗi ở lần xuất hiện đầu tiên.

S = 'Do it now and keep it simple'
x = S.partition['it']
print[x]
# Prints ['Do ', 'it', ' now and keep it simple']

Python nổi tiếng với các lệnh giống tiếng Anh, khả năng đọc mã và cú pháp lập trình đơn giản của nó. Nó cũng cung cấp cho người dùng một loạt các cấu trúc dữ liệu và danh sách là một trong số đó. Cấu trúc dữ liệu Danh sách cho phép chúng tôi lưu trữ một lượng lớn dữ liệu tuần tự trong một biến duy nhất. Một lập trình viên giỏi phải biết cách xử lý và thao tác với Danh sách. Trong bài viết này, bạn sẽ tìm hiểu cách phân vùng danh sách thành các phần có kích thước nhất định. Nhưng trước khi chúng tôi làm điều đó, hãy để chúng tôi cung cấp cho bạn bản tóm tắt nhanh về Danh sách

Danh sách là gì?

Nếu bạn đã quen thuộc với mảng trong các ngôn ngữ lập trình khác nhau thì khái niệm về danh sách sẽ đến với bạn một cách tự nhiên. Danh sách là một trong những kiểu dữ liệu có sẵn trong python, được sử dụng để lưu trữ một tập hợp dữ liệu. Chúng tôi coi danh sách là mảng có kích thước động, cũng có thể lưu trữ dữ liệu không đồng nhất. Bằng các mảng có kích thước động, điều chúng tôi muốn nói là kích thước của danh sách có thể thay đổi trong thời gian chạy. Cuối cùng, danh sách có đặc tính là có thể thay đổi, nghĩa là chúng ta có thể thay đổi danh sách bằng cách thêm hoặc xóa một phần tử ngay cả sau khi tạo chúng. Giống như một mảng, các phần tử của danh sách được lập chỉ mục, với chỉ mục của phần tử đầu tiên là 0

Ví dụ

# create a list

List = ["favTutor", 60, 32.6]

# acessing elements of the list

print["Element at the first position: " +List[0]]

print["Element at the third position: " +str[List[2]]]

 

đầu ra

Element at the first position: favTutor

Element at the third position: 32.6

 

Chia danh sách thành các khối có kích thước nhất định trong Python

Một số ứng dụng, chẳng hạn như phát triển và học máy, yêu cầu danh sách được phân chia theo một cách nhất định. e. , các khối bằng nhau có kích thước nhất định phải được tạo thành. Không chắc điều này có nghĩa là gì? . Chia danh sách thành các phần bằng nhau trả về một danh sách chứa một số danh sách, mỗi danh sách có số phần tử bằng nhau. Ví dụ: Nếu danh sách đã cho chứa m phần tử và chúng tôi đã cho rằng kích thước của mỗi phần phải là n. Khi đó danh sách mới được tạo sẽ chứa m/n danh sách, mỗi danh sách chứa n phần tử. Xem hình minh họa bên dưới

Nếu độ dài đã cho của danh sách không chia hết cho độ dài đã cho của các đoạn, thì phân vùng cuối cùng phải được lấp đầy bằng các phần tử còn lại. Nhìn vào hình minh họa dưới đây, để hiểu rõ hơn về ý tưởng này

Python cung cấp cho chúng ta 5 phương thức để chia thành các khối có kích thước bằng nhau. Bây giờ chúng ta hãy đi sâu vào từng phương pháp một

1] Sử dụng năng suất

Trước khi thảo luận về cách tiếp cận này, trước tiên chúng ta hãy hiểu ngắn gọn về năng suất là gì. Để làm cho khái niệm này dễ hiểu, chúng ta hãy vẽ một sự tương đồng giữa từ khóa trả về và từ khóa năng suất. Cái trước được sử dụng bên trong một hàm để thoát khỏi một hàm và trả lại một giá trị cho hàm gọi. Cái sau cũng giống như vậy, nhưng có một điểm khác biệt chính, năng suất trả lại một trình tạo cho hàm người gọi chứ không phải bất kỳ đối tượng hoặc cấu trúc dữ liệu nào. Để lặp lại khái niệm này, khi một hàm được gọi và luồng thực thi gặp phải một từ khóa năng suất trong hàm, hàm sẽ bị kết thúc tại dòng đó và người gọi được cung cấp một đối tượng trình tạo

Theo cách tiếp cận này, chúng tôi tạo một trình tạo để tạo ra các khối liên tiếp có kích thước nhất định

Ví dụ

# create a list
o_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# generator 
def partition[lst, size]:
    for i in range[0, len[lst], size]:
        yield lst[i : i+size]

# size of each chunk
n = 2

# partition the list
p_list = list[partition[o_list, n]]

# display original list
print["Original List: "]
print[o_list]
# display the list results
print["Partitioned List:"]
print[p_list]

 

đầu ra

________số 8

 

2] Sử dụng hiểu danh sách

Danh sách hiểu cung cấp cho chúng tôi một cách thanh lịch hơn để đạt được mục tiêu của chúng tôi. Đó là một cách ngắn gọn và súc tích để tạo một danh sách mới từ một danh sách, bộ dữ liệu, chuỗi hiện có, v.v. Việc hiểu danh sách bao gồm một biểu thức và một vòng lặp for. Vòng lặp for được sử dụng để lặp qua từng phần tử của danh sách ban đầu và biểu thức được thực thi cho từng phần tử đó. Giá trị mới của từng phần tử, được tạo bằng biểu thức được bao gồm trong danh sách mới. Bây giờ bạn có thể tự hỏi làm thế nào chúng ta có thể tách một danh sách bằng cách sử dụng khả năng hiểu Danh sách? .  

Cách tiếp cận này kết hợp các khái niệm về cắt danh sách và hiểu danh sách. Trước tiên, chúng tôi lặp qua độ dài của danh sách ban đầu, với kích thước bước bằng với kích thước khối đã cho. Sử dụng giá trị của trình vòng lặp, chúng tôi phân vùng danh sách ban đầu thành các danh sách nhỏ hơn

Ví dụ

# create a list
o_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# size of each chunk
n = 3

# partition the list using list comprehension
p_list = [o_list[i:i + n] for i in range[0, len[o_list], n]]

# display original list
print["Original List: "]
print[o_list]
# display the list results
print["Partitioned List:"]
print[p_list]

 

đầu ra

[
    [5, 0, 0], [4, 1, 0], [3, 2, 0], [2, 3, 0], [1, 4, 0],
    [0, 5, 0], [4, 0, 1], [3, 1, 1], [2, 2, 1], [1, 3, 1],
    [0, 4, 1], [3, 0, 2], [2, 1, 2], [1, 2, 2], [0, 3, 2],
    [2, 0, 3], [1, 1, 3], [0, 2, 3], [1, 0, 4], [0, 1, 4],
    [0, 0, 5]
]

0

 

3]  Sử dụng mô-đun itertools

Ngôn ngữ Python đi kèm với một số lượng lớn các mô-đun và itertools là một trong số đó. Mô-đun này có một phương thức gọi là islice[], để tạo một lát cắt của danh sách. Trước tiên chúng ta hãy xem cú pháp phương thức của hàm này để hiểu rõ hơn

[
    [5, 0, 0], [4, 1, 0], [3, 2, 0], [2, 3, 0], [1, 4, 0],
    [0, 5, 0], [4, 0, 1], [3, 1, 1], [2, 2, 1], [1, 3, 1],
    [0, 4, 1], [3, 0, 2], [2, 1, 2], [1, 2, 2], [0, 3, 2],
    [2, 0, 3], [1, 1, 3], [0, 2, 3], [1, 0, 4], [0, 1, 4],
    [0, 0, 5]
]

1

Phương thức này có bốn đối số. có thể lặp lại, bắt đầu, dừng và bước. Đối số iterable, trong trường hợp này, là danh sách mà chúng ta muốn chia thành nhiều phần. Chỉ mục bắt đầu đề cập đến chỉ mục đó của danh sách gốc mà từ đó các phần tử sẽ được đưa vào lát cắt. Mặt khác, chỉ mục dừng đề cập đến chỉ mục đó cho đến khi các phần tử được đưa vào. Đối số bước cho phép chúng ta bỏ qua các phần tử. Bây giờ hãy cho chúng tôi hiểu, làm thế nào chúng tôi có thể chia danh sách thành các phần nhỏ hơn với kích thước nhất định bằng phương pháp này

Theo cách tiếp cận này, chúng tôi tạo một phương thức trình tạo tạo ra một lát hoặc đoạn của danh sách gốc.

Ví dụ

[
    [5, 0, 0], [4, 1, 0], [3, 2, 0], [2, 3, 0], [1, 4, 0],
    [0, 5, 0], [4, 0, 1], [3, 1, 1], [2, 2, 1], [1, 3, 1],
    [0, 4, 1], [3, 0, 2], [2, 1, 2], [1, 2, 2], [0, 3, 2],
    [2, 0, 3], [1, 1, 3], [0, 2, 3], [1, 0, 4], [0, 1, 4],
    [0, 0, 5]
]

2

 

đầu ra

[
    [5, 0, 0], [4, 1, 0], [3, 2, 0], [2, 3, 0], [1, 4, 0],
    [0, 5, 0], [4, 0, 1], [3, 1, 1], [2, 2, 1], [1, 3, 1],
    [0, 4, 1], [3, 0, 2], [2, 1, 2], [1, 2, 2], [0, 3, 2],
    [2, 0, 3], [1, 1, 3], [0, 2, 3], [1, 0, 4], [0, 1, 4],
    [0, 0, 5]
]

0

 

4] Sử dụng công cụ. mô-đun itertoolz

Nếu khái niệm sử dụng năng suất hoặc hiểu danh sách gây nhầm lẫn cho bạn, thì đừng lo lắng. Bạn có thể sử dụng phương pháp đơn giản này để đạt được mục tiêu của mình. Công cụ. mô-đun itertools của python chứa phương thức partition[]. Trước tiên chúng ta hãy xem cú pháp phương thức của phương thức này

[
    [5, 0, 0], [4, 1, 0], [3, 2, 0], [2, 3, 0], [1, 4, 0],
    [0, 5, 0], [4, 0, 1], [3, 1, 1], [2, 2, 1], [1, 3, 1],
    [0, 4, 1], [3, 0, 2], [2, 1, 2], [1, 2, 2], [0, 3, 2],
    [2, 0, 3], [1, 1, 3], [0, 2, 3], [1, 0, 4], [0, 1, 4],
    [0, 0, 5]
]

4

 

Phương thức này chỉ đơn giản lấy kích thước của khối làm tham số đầu tiên và danh sách cần chia làm tham số thứ hai. Hãy xem ví dụ bên dưới, để biết chính xác cách người ta có thể sử dụng phương pháp này để đạt được phân vùng danh sách thành các phần có kích thước bằng nhau

Ví dụ

Element at the first position: favTutor

Element at the third position: 32.6

0

 

đầu ra

[
    [5, 0, 0], [4, 1, 0], [3, 2, 0], [2, 3, 0], [1, 4, 0],
    [0, 5, 0], [4, 0, 1], [3, 1, 1], [2, 2, 1], [1, 3, 1],
    [0, 4, 1], [3, 0, 2], [2, 1, 2], [1, 2, 2], [0, 3, 2],
    [2, 0, 3], [1, 1, 3], [0, 2, 3], [1, 0, 4], [0, 1, 4],
    [0, 0, 5]
]

0

 

5] Sử dụng NumPy

Numpy là một thư viện trong python rất nổi tiếng với việc xử lý các mảng một cách độc đáo. Mô-đun này chứa một số phương pháp để thực hiện các phép toán liên quan đến đại số tuyến tính, biến đổi Fourier và ma trận. Nó cũng bao gồm một phương thức gọi là array_spit[], nó thực hiện cùng nhiệm vụ mà chúng ta đang cố gắng đạt được. Cú pháp phương thức của hàm này như sau

Element at the first position: favTutor

Element at the third position: 32.6

2

 

Phương thức này lấy danh sách được phân vùng làm đối số đầu tiên và kích thước của các khối làm đối số thứ hai. Đối số trục xuất hiện khi chúng ta đang làm việc với các khung dữ liệu. Nhưng vì hôm nay chúng ta chỉ làm việc với các danh sách đơn giản nên bạn có thể bỏ qua đối số này lúc này. Bây giờ chúng ta hãy xem chức năng này đang hoạt động

Ví dụ

Element at the first position: favTutor

Element at the third position: 32.6

3

 

đầu ra

Element at the first position: favTutor

Element at the third position: 32.6

4

 

Phần kết luận

Danh sách này là một trong những khái niệm cơ bản nhất về trăn và biết cách đi xung quanh chúng là một kỹ năng mà mọi người phải sở hữu. Trong bài viết này, chúng ta đã thấy năm cách khác nhau về cách chúng ta có thể phân vùng danh sách thành các phần có kích thước nhất định. Chúng tôi yêu cầu bạn xem xét kỹ lưỡng tất cả các phương pháp đã thảo luận ở trên vì chúng rất hiệu quả và hữu ích

Làm cách nào để phân vùng mảng trong Python?

Sự khác biệt giữa hàm partition[] và split[] là gì?

Phương thức partition[] trong máy tính là gì?

Làm thế nào để sử dụng phân vùng trong gấu trúc?