Tôi đã đánh giá điểm này khác nhau theo Python 3.7.0 [Ipython].
TLDR
- nhanh nhất [khi biểu tượng phân chia
3 được biết đến]: Regex được biên dịch sẵn.str = "stackvidhya" print[str[0:5]]
- nhanh nhất [mặt khác]:
4.str = "stackvidhya" print[str[0:5]]
- An toàn [tức là, khi
3 có thể không có trongstr = "stackvidhya" print[str[0:5]]
6]: phân vùng, chia.str = "stackvidhya" print[str[0:5]]
- Không an toàn: Index, Regex.
Mã số
import string, random, re
SYMBOLS = string.ascii_uppercase + string.digits
SIZE = 100
def create_test_set[string_length]:
for _ in range[SIZE]:
random_string = ''.join[random.choices[SYMBOLS, k=string_length]]
yield [random.choice[random_string], random_string]
for string_length in [2**4, 2**8, 2**16, 2**32]:
print["\nString length:", string_length]
print[" regex [compiled]:", end=" "]
test_set_for_regex = [[re.compile["[.*?]" + c].match, s] for [c, s] in test_set]
%timeit [re_match[s].group[] for [re_match, s] in test_set_for_regex]
test_set = list[create_test_set[16]]
print[" partition: ", end=" "]
%timeit [s.partition[c][0] for [c, s] in test_set]
print[" index: ", end=" "]
%timeit [s[:s.index[c]] for [c, s] in test_set]
print[" split [limited]: ", end=" "]
%timeit [s.split[c, 1][0] for [c, s] in test_set]
print[" split: ", end=" "]
%timeit [s.split[c][0] for [c, s] in test_set]
print[" regex: ", end=" "]
%timeit [re.match["[.*?]" + c, s].group[] for [c, s] in test_set]
Kết quả
String length: 16
regex [compiled]: 156 ns ± 4.41 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.3 µs ± 430 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 26.1 µs ± 341 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.8 µs ± 1.26 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.3 µs ± 835 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 4.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 256
regex [compiled]: 167 ns ± 2.7 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 694 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
index: 28.6 µs ± 2.73 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.4 µs ± 979 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 31.5 µs ± 4.86 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 148 µs ± 7.05 µs per loop [mean ± std. dev. of 7 runs, 1000 loops each]
String length: 65536
regex [compiled]: 173 ns ± 3.95 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 613 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 515 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.2 µs ± 796 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.5 µs ± 377 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 1.5 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 4294967296
regex [compiled]: 165 ns ± 1.2 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.9 µs ± 144 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 571 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.1 µs ± 472 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 28.1 µs ± 1.69 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 137 µs ± 6.53 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
Nếu bạn muốn chỉ nhận được một yếu tố từ danh sách, thì bạn có thể sử dụng chỉ mục danh sách để truy cập các yếu tố.
Đây là cách bạn có thể trích xuất chuỗi con bằng cách sử dụng các biểu thức thông thường còn được gọi là khớp mẫu.in python using the str[0:n] option.
Sự kết luận
Để tóm tắt, bạn đã học được cách lấy một chuỗi chuỗi trong Python bằng cách sử dụng ký hiệu cắt. Ngoài ra, bạn đã học được cách sử dụng ký hiệu cắt để có được chất nền trong các tình huống khác nhau và cách trích xuất chuỗi con bằng cách sử dụng các biểu thức thông thường và khớp mẫu.
Đoạn trích
str = "stackvidhya"
print[str[0:5]]
Where,
- Nếu bạn có bất kỳ câu hỏi, bình luận dưới đây.
Bạn cũng có thể thích
Đầu ra
stack
Danh sách Python đến Chuỗi - Hướng dẫn dứt khoát
Kiểm tra xem chuỗi có chứa một chuỗi con trong Python không
Làm thế nào để bạn chia một chuỗi trước một ký tự cụ thể trong Python?
Python Chuỗi chia [] Phương thức Cú pháp.
- Cú pháp: str.split [phân tách, maxsplit].
- Thông số :.
- Python Subring trước ký tự
- Python Subring sau nhân vật
- Chất nền Python cho đến khi ký tự
- Nhận ký tự đầu tiên của chuỗi
- Nhận ký tự cuối cùng của chuỗi
- Python Substring sử dụng Regex
- Sự kết luận
- Bạn cũng có thể thích
Chất nền Python sử dụng ký hiệu cắt lát
Trong Python, bạn có thể sử dụng ký hiệu lát cắt để lấy phần phụ từ
stack
0.Ký hiệu cắt chấp nhận ba tham số tùy chọn như hình dưới đây.
string[start: end: step]
Where,
1 - đối tượng chuỗi mà từ đó nên trích xuấtstack
2 - Vị trí bắt đầu mà từ đó nên trích xuất chuỗi con. Vị trí bắt đầu là bao gồm.inclusive.stack
3 - Vị trí kết thúc cho đến khi phần phụ nên được trích xuất. Vị trí cuối là độc quyền.exclusive.stack
4 - Số lượng ký tự để bước sau khi bao gồm mỗi ký tự. Theo mặc định, nó 1.stack
Ví dụ dưới đây cho thấy cách lấy phần phụ của năm ký tự đầu tiên từ một chuỗi.
Thí dụ
string = "stackvidhya"
print[string[0:5]]
Bạn sẽ thấy năm ký tự đầu tiên được trích xuất dưới dạng con.
Đầu ra
stack
Python Subring sử dụng chỉ mục
Trong phần này, bạn sẽ học cách trích xuất một chuỗi con bằng các vị trí chỉ mục.
Sử dụng ví dụ dưới đây để tìm nạp chuỗi con từ vị trí chỉ mục 5 đến 11.substring from the index position 5 to 11.
Đoạn trích
string = "stackvidhya"
print[string[5:11]]
Where,
1 - Tên của chuỗi mà từ đó nên trích xuấtstack
9 -Chỉ số khởi động của chuỗi con. Bao gồmInclusivestr = "stackvidhya" print[str[0:5]]
7 - Chỉ số kết thúc của chuỗi con. Loại trừExclusivestack
Bạn có thể thấy phần phụ được trích xuất từ vị trí
str = "stackvidhya"
print[str[0:5]]
9 đến stack
9 như được hiển thị bên dưới.Đầu ra
stack
Python Subring sử dụng chỉ mục
Trong phần này, bạn sẽ học cách trích xuất một chuỗi con bằng các vị trí chỉ mục.
Sử dụng ví dụ dưới đây để tìm nạp chuỗi con từ vị trí chỉ mục 5 đến 11., if you use
string[start: end: step]
1 as a step parameter, 1 character will be ignored after including each parameter in the substring. This
ideally means, 2 steps will be moved after including a character.Đoạn trích
string = "stackvidhya"
print[string[0:5:2]]
Where,
1 - Tên của chuỗi mà từ đó nên trích xuấtinclusivestack
9 -Chỉ số khởi động của chuỗi con. Bao gồmExclusivestr = "stackvidhya" print[str[0:5]]
7 - Chỉ số kết thúc của chuỗi con. Loại trừstack
Bạn có thể thấy phần phụ được trích xuất từ vị trí
str = "stackvidhya"
print[str[0:5]]
9 đến stack
9 như được hiển thị bên dưới.Đầu ra
String length: 16
regex [compiled]: 156 ns ± 4.41 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.3 µs ± 430 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 26.1 µs ± 341 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.8 µs ± 1.26 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.3 µs ± 835 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 4.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 256
regex [compiled]: 167 ns ± 2.7 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 694 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
index: 28.6 µs ± 2.73 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.4 µs ± 979 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 31.5 µs ± 4.86 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 148 µs ± 7.05 µs per loop [mean ± std. dev. of 7 runs, 1000 loops each]
String length: 65536
regex [compiled]: 173 ns ± 3.95 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 613 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 515 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.2 µs ± 796 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.5 µs ± 377 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 1.5 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 4294967296
regex [compiled]: 165 ns ± 1.2 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.9 µs ± 144 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 571 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.1 µs ± 472 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 28.1 µs ± 1.69 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 137 µs ± 6.53 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
0Python Subring sử dụng chỉ mục
Python Subring trước ký tự
Trong phần này, bạn sẽ học cách trích xuất một chuỗi con bằng các vị trí chỉ mục.before a specific character using the
string = "stackvidhya"
print[string[0:5]]
0 method.Sử dụng ví dụ dưới đây để tìm nạp chuỗi con từ vị trí chỉ mục 5 đến 11.last occurrence of the delimiter and it generates tuples that contain three elements where.
- Đoạn tríchuntil the last occurrence of the delimiter.
1 - Tên của chuỗi mà từ đó nên trích xuấtstack
9 -Chỉ số khởi động của chuỗi con. Bao gồmlast occurence of the delimiter.str = "stackvidhya" print[str[0:5]]
stack
7 - Chỉ số kết thúc của chuỗi con. Loại trừBạn có thể thấy phần phụ được trích xuất từ vị trí
str = "stackvidhya"
print[str[0:5]]
9 đến stack
9 như được hiển thị bên dưới.Đoạn trích
String length: 16
regex [compiled]: 156 ns ± 4.41 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.3 µs ± 430 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 26.1 µs ± 341 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.8 µs ± 1.26 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.3 µs ± 835 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 4.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 256
regex [compiled]: 167 ns ± 2.7 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 694 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
index: 28.6 µs ± 2.73 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.4 µs ± 979 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 31.5 µs ± 4.86 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 148 µs ± 7.05 µs per loop [mean ± std. dev. of 7 runs, 1000 loops each]
String length: 65536
regex [compiled]: 173 ns ± 3.95 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 613 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 515 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.2 µs ± 796 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.5 µs ± 377 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 1.5 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 4294967296
regex [compiled]: 165 ns ± 1.2 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.9 µs ± 144 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 571 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.1 µs ± 472 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 28.1 µs ± 1.69 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 137 µs ± 6.53 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
1Where,
1 - Tên của chuỗi mà từ đó nên trích xuấtstack
9 -Chỉ số khởi động của chuỗi con. Bao gồmstr = "stackvidhya" print[str[0:5]]
7 - Chỉ số kết thúc của chuỗi con. Loại trừstack
Bạn có thể thấy phần phụ được trích xuất từ vị trí
str = "stackvidhya"
print[str[0:5]]
9 đến stack
9 như được hiển thị bên dưới.Đầu ra
stack
Python Subring sử dụng chỉ mục
Python Subring sau nhân vật
Trong phần này, bạn sẽ học cách trích xuất một chuỗi con bằng các vị trí chỉ mục.after a specific character using the
stack
2 method.Sử dụng ví dụ dưới đây để tìm nạp chuỗi con từ vị trí chỉ mục 5 đến 11.first occurrence of the delimiter and it generates tuples that contain three elements where.
- Đoạn tríchuntil the first occurrence of the delimiter.
1 - Tên của chuỗi mà từ đó nên trích xuấtstack
9 -Chỉ số khởi động của chuỗi con. Bao gồmfirst occurence of the delimiter.str = "stackvidhya" print[str[0:5]]
stack
7 - Chỉ số kết thúc của chuỗi con. Loại trừBạn có thể thấy phần phụ được trích xuất từ vị trí
str = "stackvidhya"
print[str[0:5]]
9 đến stack
9 như được hiển thị bên dưới.Đoạn trích
String length: 16
regex [compiled]: 156 ns ± 4.41 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.3 µs ± 430 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 26.1 µs ± 341 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.8 µs ± 1.26 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.3 µs ± 835 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 4.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 256
regex [compiled]: 167 ns ± 2.7 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 694 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
index: 28.6 µs ± 2.73 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.4 µs ± 979 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 31.5 µs ± 4.86 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 148 µs ± 7.05 µs per loop [mean ± std. dev. of 7 runs, 1000 loops each]
String length: 65536
regex [compiled]: 173 ns ± 3.95 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 613 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 515 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.2 µs ± 796 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.5 µs ± 377 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 1.5 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 4294967296
regex [compiled]: 165 ns ± 1.2 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.9 µs ± 144 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 571 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.1 µs ± 472 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 28.1 µs ± 1.69 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 137 µs ± 6.53 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
3Where,
1 - Tên của chuỗi mà từ đó nên trích xuấtstack
8 - Để phân vùng chuỗi dựa trên dấu phân cáchstack
4.string = "stackvidhya" print[string[0:5]]
0 - Để truy cập phần tử cuối cùng trong bộ dữ liệu được tạo bởistring = "stackvidhya" print[string[5:11]]
2. Điều này là để trích xuất chuỗi con sau ký tự phân cách.after the delimiter character.stack
Bạn sẽ thấy đầu ra
stack
0 là một nền tảng sau ký tự string = "stackvidhya"
print[string[0:5]]
4.Đầu ra
String length: 16
regex [compiled]: 156 ns ± 4.41 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.3 µs ± 430 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 26.1 µs ± 341 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.8 µs ± 1.26 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.3 µs ± 835 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 4.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 256
regex [compiled]: 167 ns ± 2.7 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 694 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
index: 28.6 µs ± 2.73 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.4 µs ± 979 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 31.5 µs ± 4.86 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 148 µs ± 7.05 µs per loop [mean ± std. dev. of 7 runs, 1000 loops each]
String length: 65536
regex [compiled]: 173 ns ± 3.95 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 613 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 515 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.2 µs ± 796 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.5 µs ± 377 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 1.5 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 4294967296
regex [compiled]: 165 ns ± 1.2 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.9 µs ± 144 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 571 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.1 µs ± 472 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 28.1 µs ± 1.69 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 137 µs ± 6.53 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
4Đây là cách bạn có thể trích xuất chuỗi con sau một nhân vật cụ thể.
Chất nền Python cho đến khi ký tự
Bạn có thể trích xuất một chuỗi con từ một chuỗi cho đến khi một ký tự cụ thể bằng phương pháp
stack
2.until a specific character using the stack
2 method. stack
2 Phương pháp phân vùng chuỗi đã cho dựa trên sự xuất hiện đầu tiên của dấu phân cách và nó tạo ra các bộ dữ liệu có chứa ba phần tử trong đó,first occurrence of the delimiter and it generates tuples that contain three elements where,- Phần tử đầu tiên sẽ là chuỗi cho đến khi lần xuất hiện đầu tiên của dấu phân cách.until the first occurrence of the delimiter.
- Phần tử thứ hai sẽ là chuỗi phân cách chính.
- Phần tử thứ ba sẽ là chuỗi sau lần xuất hiện đầu tiên của dấu phân cách.first occurence of the delimiter.
Ngoài ra còn có một phương thức được gọi là
stack
4 chia chuỗi nhiều lần nếu chuỗi chứa dấu phân cách nhiều lần. Trong khi stack
2 chỉ chia chuỗi một lần ngay cả khi dấu phân cách tồn tại nhiều lần trong chuỗi.Sử dụng đoạn trích dưới đây để phân chia chuỗi cho đến khi ký tự
string = "stackvidhya"
print[string[0:5]]
4.Đoạn trích
String length: 16
regex [compiled]: 156 ns ± 4.41 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.3 µs ± 430 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 26.1 µs ± 341 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.8 µs ± 1.26 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.3 µs ± 835 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 4.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 256
regex [compiled]: 167 ns ± 2.7 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 694 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
index: 28.6 µs ± 2.73 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.4 µs ± 979 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 31.5 µs ± 4.86 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 148 µs ± 7.05 µs per loop [mean ± std. dev. of 7 runs, 1000 loops each]
String length: 65536
regex [compiled]: 173 ns ± 3.95 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 613 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 515 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.2 µs ± 796 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.5 µs ± 377 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 1.5 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 4294967296
regex [compiled]: 165 ns ± 1.2 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.9 µs ± 144 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 571 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.1 µs ± 472 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 28.1 µs ± 1.69 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 137 µs ± 6.53 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
5Where,
1 -Source chuỗi mà từ đó nên trích xuấtstack
8 - Để phân vùng chuỗi dựa trên dấu phân cáchstack
4.string = "stackvidhya" print[string[0:5]]
8 - Để truy cập phần tử đầu tiên trong bộ dữ liệu được tạo bởistring = "stackvidhya" print[string[0:5]]
2. Điều này là để trích xuất chuỗi con cho đến khi ký tự phân cách.until the delimiter character.stack
Bạn sẽ thấy đầu ra
stack
0 là một nền tảng cho đến khi ký tự string = "stackvidhya"
print[string[0:5]]
4.Đầu ra
stack
Đây là cách bạn có thể trích xuất chuỗi con sau một nhân vật cụ thể.
Chất nền Python cho đến khi ký tự
Bạn có thể trích xuất một chuỗi con từ một chuỗi cho đến khi một ký tự cụ thể bằng phương pháp
stack
2.using the index 0.Đoạn trích
String length: 16
regex [compiled]: 156 ns ± 4.41 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.3 µs ± 430 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 26.1 µs ± 341 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.8 µs ± 1.26 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.3 µs ± 835 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 4.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 256
regex [compiled]: 167 ns ± 2.7 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 694 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
index: 28.6 µs ± 2.73 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.4 µs ± 979 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 31.5 µs ± 4.86 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 148 µs ± 7.05 µs per loop [mean ± std. dev. of 7 runs, 1000 loops each]
String length: 65536
regex [compiled]: 173 ns ± 3.95 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 613 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 515 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.2 µs ± 796 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.5 µs ± 377 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 1.5 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 4294967296
regex [compiled]: 165 ns ± 1.2 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.9 µs ± 144 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 571 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.1 µs ± 472 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 28.1 µs ± 1.69 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 137 µs ± 6.53 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
7Where,
1 -Source chuỗi mà từ đó nên trích xuấtstack
8 - Để truy cập phần tử đầu tiên trong bộ dữ liệu được tạo bởistring = "stackvidhya" print[string[0:5]]
2. Điều này là để trích xuất chuỗi con cho đến khi ký tự phân cách.stack
Đầu ra
String length: 16
regex [compiled]: 156 ns ± 4.41 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.3 µs ± 430 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 26.1 µs ± 341 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.8 µs ± 1.26 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.3 µs ± 835 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 4.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 256
regex [compiled]: 167 ns ± 2.7 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 694 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
index: 28.6 µs ± 2.73 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.4 µs ± 979 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 31.5 µs ± 4.86 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 148 µs ± 7.05 µs per loop [mean ± std. dev. of 7 runs, 1000 loops each]
String length: 65536
regex [compiled]: 173 ns ± 3.95 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 613 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 515 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.2 µs ± 796 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.5 µs ± 377 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 1.5 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 4294967296
regex [compiled]: 165 ns ± 1.2 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.9 µs ± 144 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 571 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.1 µs ± 472 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 28.1 µs ± 1.69 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 137 µs ± 6.53 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
8Đây là cách bạn có thể trích xuất chuỗi con sau một nhân vật cụ thể.
Chất nền Python cho đến khi ký tự
Bạn có thể trích xuất một chuỗi con từ một chuỗi cho đến khi một ký tự cụ thể bằng phương pháp
stack
2.using the index -1. stack
8 sign indicates that the string should be traversed from the end.Đoạn trích
String length: 16
regex [compiled]: 156 ns ± 4.41 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.3 µs ± 430 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 26.1 µs ± 341 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.8 µs ± 1.26 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.3 µs ± 835 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 4.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 256
regex [compiled]: 167 ns ± 2.7 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 694 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
index: 28.6 µs ± 2.73 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.4 µs ± 979 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 31.5 µs ± 4.86 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 148 µs ± 7.05 µs per loop [mean ± std. dev. of 7 runs, 1000 loops each]
String length: 65536
regex [compiled]: 173 ns ± 3.95 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 20.9 µs ± 613 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 515 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 27.2 µs ± 796 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 26.5 µs ± 377 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 128 µs ± 1.5 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
String length: 4294967296
regex [compiled]: 165 ns ± 1.2 ns per loop [mean ± std. dev. of 7 runs, 10000000 loops each]
partition: 19.9 µs ± 144 ns per loop [mean ± std. dev. of 7 runs, 100000 loops each]
index: 27.7 µs ± 571 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split [limited]: 26.1 µs ± 472 ns per loop [mean ± std. dev. of 7 runs, 10000 loops each]
split: 28.1 µs ± 1.69 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
regex: 137 µs ± 6.53 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
9Where,
1 -Source chuỗi mà từ đó nên trích xuấtstack
8 - Để truy cập phần tử đầu tiên trong bộ dữ liệu được tạo bởistring = "stackvidhya" print[string[0:5]]
2. Điều này là để trích xuất chuỗi con cho đến khi ký tự phân cách.stack
Đầu ra
str = "stackvidhya"
print[str[0:5]]
0Đây là cách bạn có thể trích xuất chuỗi con sau một nhân vật cụ thể.
Chất nền Python cho đến khi ký tự
Bạn có thể trích xuất một chuỗi con từ một chuỗi cho đến khi một ký tự cụ thể bằng phương pháp
stack
2. stack
2 Phương pháp phân vùng chuỗi đã cho dựa trên sự xuất hiện đầu tiên của dấu phân cách và nó tạo ra các bộ dữ liệu có chứa ba phần tử trong đó,Phần tử đầu tiên sẽ là chuỗi cho đến khi lần xuất hiện đầu tiên của dấu phân cách.
Phần tử thứ hai sẽ là chuỗi phân cách chính.
- Phần tử thứ ba sẽ là chuỗi sau lần xuất hiện đầu tiên của dấu phân cách.
- Ngoài ra còn có một phương thức được gọi là
4 chia chuỗi nhiều lần nếu chuỗi chứa dấu phân cách nhiều lần. Trong khistack
2 chỉ chia chuỗi một lần ngay cả khi dấu phân cách tồn tại nhiều lần trong chuỗi.stack
Sử dụng đoạn trích dưới đây để phân chia chuỗi cho đến khi ký tự
string = "stackvidhya"
print[string[0:5]]
4.Đoạn trích
stack
1 -Source chuỗi mà từ đó nên trích xuấtĐoạn trích
str = "stackvidhya"
print[str[0:5]]
1 stack
1 -Source chuỗi mà từ đó nên trích xuấtstring = "stackvidhya"
print[string[0:5]]
8 - Để truy cập phần tử đầu tiên trong bộ dữ liệu được tạo bởi stack
2. Điều này là để trích xuất chuỗi con cho đến khi ký tự phân cách.Đầu ra
str = "stackvidhya"
print[str[0:5]]
2Bạn sẽ thấy đầu ra
stack
0 là một nền tảng cho đến khi ký tự string = "stackvidhya"
print[string[0:5]]
4.Đây là cách bạn có thể trích xuất một chuỗi con cho đến khi một ký tự cụ thể.
Nhận ký tự đầu tiên của chuỗi
Bạn có thể nhận được ký tự đầu tiên của chuỗi bằng cách sử dụng chỉ mục 0.
stack
1 - Chuỗi nguồn để trích xuất chuỗi con
stack
8 - Để có được ký tự đầu tiên của chuỗistring = "stackvidhya" print[string[0:5]]
- Đây là cách bạn có thể có được ký tự đầu tiên của chuỗi.