Dưới đây là hai cách tiếp cận chung. Có lẽ đáng để thêm vào lib của riêng bạn. Đầu tiên yêu cầu vật phẩm có thể cắt được và thứ hai hoạt động với bất kỳ lần lặp nào [nhưng yêu cầu hàm tạo của chúng phải chấp nhận điều đó].
def split_bylen[item, maxlen]:
'''
Requires item to be sliceable [with __getitem__ defined]
'''
return [item[ind:ind+maxlen] for ind in range[0, len[item], maxlen]]
#You could also replace outer [ ] brackets with [ ] to use as generator.
def split_bylen_any[item, maxlen, constructor=None]:
'''
Works with any iterables.
Requires item's constructor to accept iterable or alternatively
constructor argument could be provided [otherwise use item's class]
'''
if constructor is None: constructor = item.__class__
return [constructor[part] for part in zip[* [[iter[item]] * maxlen]]]
#OR: return map[constructor, zip[* [[iter[item]] * maxlen]]]
# which would be faster if you need an iterable, not list
Vì vậy, trong trường hợp của chủ đề, việc sử dụng là:
string = 'Baboons love bananas'
parts = 5
splitlen = -[-len[string] // parts] # is alternative to math.ceil[len/parts]
first_method = split_bylen[string, splitlen]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
second_method = split_bylen_any[string, splitlen, constructor=''.join]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
Chia một chuỗi thành các khối kích thước cố định trong python #
Để chia một chuỗi thành các khối kích thước cố định:
- Tuyên bố một biến lưu trữ một danh sách trống.
- Lặp lại trên một phạm vi độ dài của chuỗi bằng một bước.
- Trên mỗi lần lặp, nối một chuỗi độ dài n vào danh sách.
Copied!
my_str = 'abcdefgh' my_list = [] n = 2 for i in range[0, len[my_str], n]: my_list.append[my_str[i:i+n]] print[my_list] # 👉️ ['ab', 'cd', 'ef', 'gh'] # -------------------------------------------- # using list comprehension my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]] print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh']
Chúng tôi đã sử dụng lớp range
để có được một loạt các chỉ số đại diện cho ký tự đầu tiên trong mỗi đoạn.
Copied!
my_str = 'abcdefgh' my_list = [] n = 2 # 👇️ [0, 2, 4, 6] print[list[range[0, len[my_str], n]]]
Lớp phạm vi thường được sử dụng để lặp lại một số lần cụ thể trong các vòng
string = 'Baboons love bananas'
parts = 5
splitlen = -[-len[string] // parts] # is alternative to math.ceil[len/parts]
first_method = split_bylen[string, splitlen]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
second_method = split_bylen_any[string, splitlen, constructor=''.join]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
0 và lấy các tham số sau:
1 | Một số nguyên đại diện cho sự khởi đầu của phạm vi [mặc định là 2] |
3 | Đi lên, nhưng không bao gồm số nguyên được cung cấp |
4 | Phạm vi sẽ bao gồm mọi số N từ 1 đến 3 [mặc định là 7] |
Cú pháp để cắt chuỗi là
string = 'Baboons love bananas'
parts = 5
splitlen = -[-len[string] // parts] # is alternative to math.ceil[len/parts]
first_method = split_bylen[string, splitlen]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
second_method = split_bylen_any[string, splitlen, constructor=''.join]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
8.Copied!
my_str = 'abcdefgh' my_list = [] n = 2 for i in range[0, len[my_str], n]: my_list.append[my_str[i:i+n]] print[my_list] # 👉️ ['ab', 'cd', 'ef', 'gh']
Lưu ý rằng chỉ số
string = 'Baboons love bananas'
parts = 5
splitlen = -[-len[string] // parts] # is alternative to math.ceil[len/parts]
first_method = split_bylen[string, splitlen]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
second_method = split_bylen_any[string, splitlen, constructor=''.join]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
1 bao gồm, trong khi chỉ số string = 'Baboons love bananas'
parts = 5
splitlen = -[-len[string] // parts] # is alternative to math.ceil[len/parts]
first_method = split_bylen[string, splitlen]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
second_method = split_bylen_any[string, splitlen, constructor=''.join]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
3 là độc quyền.Trên mỗi lần lặp, chúng tôi nhận được chỉ số bắt đầu từ mục hiện tại trong range
và tính toán chỉ số
string = 'Baboons love bananas'
parts = 5
splitlen = -[-len[string] // parts] # is alternative to math.ceil[len/parts]
first_method = split_bylen[string, splitlen]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
second_method = split_bylen_any[string, splitlen, constructor=''.join]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
3 bằng cách thêm chỉ mục bắt đầu vào độ dài chunk mong muốn.Ngoài ra, bạn có thể sử dụng một danh sách hiểu.
Copied!
my_str = 'abcdefgh' n = 2 my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]] print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh']
Danh sách các hệ thống được sử dụng để thực hiện một số hoạt động cho mọi yếu tố hoặc chọn một tập hợp con của các phần tử đáp ứng một điều kiện.
Giải pháp này là phiên bản một dòng của đoạn mã đầu tiên sử dụng vòng lặp
string = 'Baboons love bananas'
parts = 5
splitlen = -[-len[string] // parts] # is alternative to math.ceil[len/parts]
first_method = split_bylen[string, splitlen]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
second_method = split_bylen_any[string, splitlen, constructor=''.join]
#Result :['Babo', 'ons ', 'love', ' ban', 'anas']
0.Nếu chuỗi có độ dài là một số lẻ, mục cuối cùng trong danh sách sẽ chứa ít ký tự hơn.
Copied!
my_str = 'abcdefghi' n = 2 my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]] print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh', 'i']
Bạn cũng có thể sử dụng vòng lặp
4 để chia chuỗi mỗi ký tự thứ n.Copied!
my_str = 'abcdefgh' my_list = [] n = 2 for i in range[0, len[my_str], n]: my_list.append[my_str[i:i+n]] print[my_list] # 👉️ ['ab', 'cd', 'ef', 'gh'] # -------------------------------------------- # using list comprehension my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]] print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh']
Copied!
my_str = 'abcdefghi' my_str_copy = my_str my_list = [] n = 2 while my_str_copy: my_list.append[my_str_copy[:n]] my_str_copy = my_str_copy[n:] # 👇️ ['ab', 'cd', 'ef', 'gh', 'i'] print[my_list]
Chúng tôi đã khai báo một biến thứ hai lưu trữ cùng một chuỗi chính xác.
Trên mỗi lần lặp trong vòng lặp Copied! Copied! Copied!
4, chúng tôi nối các ký tự my_str = 'abcdefgh'
my_list = []
n = 2
for i in range[0, len[my_str], n]:
my_list.append[my_str[i:i+n]]
print[my_list] # 👉️ ['ab', 'cd', 'ef', 'gh']
# --------------------------------------------
# using list comprehension
my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]]
print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh']
6 đầu tiên của chuỗi được sao chép vào danh sách và xóa các ký tự my_str = 'abcdefgh'
my_list = []
n = 2
for i in range[0, len[my_str], n]:
my_list.append[my_str[i:i+n]]
print[my_list] # 👉️ ['ab', 'cd', 'ef', 'gh']
# --------------------------------------------
# using list comprehension
my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]]
print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh']
6 đầu tiên khỏi chuỗi được sao chép.my_str = 'abcdefgh'
my_list = []
n = 2
for i in range[0, len[my_str], n]:
my_list.append[my_str[i:i+n]]
print[my_list] # 👉️ ['ab', 'cd', 'ef', 'gh']
# --------------------------------------------
# using list comprehension
my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]]
print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh']
Bạn cũng có thể sử dụng phương thức
8 để chia một chuỗi thành các khối kích thước cố định.Copied!
my_str = 'abcdefgh' my_list = [] n = 2 for i in range[0, len[my_str], n]: my_list.append[my_str[i:i+n]] print[my_list] # 👉️ ['ab', 'cd', 'ef', 'gh'] # -------------------------------------------- # using list comprehension my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]] print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh']
Để chia một chuỗi thành các khối kích thước cố định:
- Nhập phương thức
8 từ mô -đunCopied!
my_str = 'abcdefgh' my_list = [] n = 2 for i in range[0, len[my_str], n]: my_list.append[my_str[i:i+n]] print[my_list] # 👉️ ['ab', 'cd', 'ef', 'gh'] # -------------------------------------------- # using list comprehension my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]] print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh']
0.Copied!
my_str = 'abcdefgh' my_list = [] n = 2 # 👇️ [0, 2, 4, 6] print[list[range[0, len[my_str], n]]]
- Chuyển chuỗi và chiều rộng tối đa của mỗi lát cho phương thức.
- Phương thức
8 sẽ chia chuỗi thành một danh sách với các mục có độ dài tối đa N.Copied!
my_str = 'abcdefgh' my_list = [] n = 2 for i in range[0, len[my_str], n]: my_list.append[my_str[i:i+n]] print[my_list] # 👉️ ['ab', 'cd', 'ef', 'gh'] # -------------------------------------------- # using list comprehension my_list_2 = [my_str[i:i+n] for i in range[0, len[my_str], n]] print[my_list_2] # 👉️ ['ab', 'cd', 'ef', 'gh']
Copied!
from textwrap import wrap my_str = 'abcdefgh' n = 2 my_list = wrap[ my_str, n, drop_whitespace=False, break_on_hyphens=False ] # 👇️ ['ab', 'cd', 'ef', 'gh'] print[my_list]
Phương thức TextWrap.Wrap sẽ chia chuỗi thành một danh sách, để mọi mục danh sách dài nhất là nhiều ký tự.
Chúng tôi đặt đối số từ khóa
2 thànhCopied!
my_str = 'abcdefgh' my_list = [] n = 2 # 👇️ [0, 2, 4, 6] print[list[range[0, len[my_str], n]]]
3 vì hành vi mặc định của phương thức là loại bỏ khoảng trắng.Copied!
my_str = 'abcdefgh' my_list = [] n = 2 # 👇️ [0, 2, 4, 6] print[list[range[0, len[my_str], n]]]