Hướng dẫn how do you get a string before a specific string in python? - làm cách nào để lấy một chuỗi trước một chuỗi cụ thể trong python?

Question

Tôi đã đánh giá điểm này khác nhau theo Python 3.7.0 (Ipython).

Nội dung chính Show

Kết quả
Nhận một phần của chuỗi trước một ký tự cụ thể trong Python #
Nhận một phần của chuỗi trước một ký tự cụ thể bằng cách sử dụng str.index () #
Làm thế nào để bạn có được một chuỗi trước một chuỗi con cụ thể?
Làm thế nào để bạn trích xuất một chuỗi từ một chuỗi trong Python?
Làm thế nào để bạn cắt một chuỗi trước một ký tự cụ thể trong Python?
Làm cách nào để tìm thứ tự của một chuỗi trong Python?

TLDR

nhanh nhất (khi biểu tượng phân chia

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)

1 được biết đến): Regex được biên dịch sẵn.

nhanh nhất (mặt khác):

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)

2.

An toàn (tức là, khi

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)

1 có thể không có trong

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): phân vùng, chia.

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)

Nhận một phần của chuỗi trước một ký tự cụ thể trong Python #

Để có được phần của chuỗi trước một ký tự cụ thể:

Sử dụng phương thức

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

8 để lấy chỉ mục của ký tự.

Sử dụng cắt chuỗi để có được mọi thứ trước chỉ mục.
Tùy chọn, sử dụng toán tử bổ sung (+) để thêm ký tự.

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

Phương thức str.index trả về chỉ mục của lần xuất hiện đầu tiên của chuỗi con được cung cấp trong chuỗi.

Chúng tôi đã sử dụng cắt chuỗi để có được một phần của chuỗi trước ký tự đã cho.

Cú pháp để cắt chuỗi là

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

0.

Chỉ số

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

1 bao gồm, trong khi chỉ số

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

2 là độc quyền (lên đến, nhưng không bao gồm).

Các chỉ mục Python là dựa trên 0, do đó, ký tự đầu tiên trong một chuỗi có chỉ số

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)

6 và ký tự cuối cùng có chỉ số là

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

4 hoặc

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

5.

Slice

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

6 bắt đầu tại INDEX

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)

6 và đi lên, nhưng không bao gồm chỉ mục được chỉ định.

Bạn có thể sử dụng toán tử bổ sung (+) nếu bạn cần thêm ký tự vào chuỗi.

Phương thức

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

8 tăng

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

9 nếu không tìm thấy chuỗi con trong chuỗi.

Bạn có thể sử dụng câu lệnh

Copied!
string = 'bobby-hadz-com'

character = '-'

before_character = string.split(character, 1)[0] + character
print(before_character)  # 👉️ 'bobby-'

0 để xử lý kịch bản trong đó không tìm thấy chuỗi con trong chuỗi.

Chất nền được chỉ định không chứa trong chuỗi, do đó

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

9 được nâng lên và sau đó được xử lý bởi khối

Copied!



string = 'bobby-hadz-com'
character = '-'
before_character = string.split(character, 1)[0] + character
print(before_character) # 👉️ 'bobby-'

2.

Chúng tôi đặt đối số

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 thành

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

0 vì chúng tôi chỉ muốn chia chuỗi trên lần xuất hiện đầu tiên của ký tự đã cho.

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

Nếu bạn cần đưa ký tự vào chuỗi cuối cùng, hãy sử dụng toán tử bổ sung.

Copied!
string = 'bobby-hadz-com'

character = '-'

before_character = string.split(character, 1)[0] + character
print(before_character)  # 👉️ 'bobby-'

Cách tiếp cận này cũng có thể được sử dụng để có được một phần của chuỗi trước một chuỗi con cụ thể, nó không phải là một ký tự duy nhất.

Nếu bạn cần có được một phần của chuỗi trước lần xuất hiện cuối cùng của ký tự, hãy sử dụng phương thức

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

1.

Copied!
string = 'bobby-hadz-com'

character = '-'

before_character = string.rsplit(character, 1)[0]
print(before_character)  # 👉️ bobby-hadz

Ngoại trừ việc chia tách từ bên phải,

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

2 hoạt động như

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

3.

Phương thức

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

1 chia chuỗi từ bên phải và với

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 được đặt thành

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

0, nó chỉ chia tách một lần.

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby-hadz', 'com']
print(string.rsplit(character, 1))

Mục danh sách tại Index

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)

6 chứa mọi thứ trước khi xuất hiện cuối cùng của ký tự đã cho.

Ngoài ra, bạn có thể sử dụng phương pháp

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

8.

Nhận một phần của chuỗi trước một ký tự cụ thể bằng cách sử dụng str.index () #

Để có được phần của chuỗi trước một ký tự cụ thể:

Sử dụng phương thức

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

8 để lấy chỉ mục của ký tự.

Sử dụng cắt chuỗi để có được mọi thứ trước chỉ mục.
Tùy chọn, sử dụng toán tử bổ sung (+) để thêm ký tự.

Copied!
string = 'bobby-hadz-com'

before_character = string[:string.index('-')]
print(before_character)  # 👉️ 'bobby'

Phương thức str.index trả về chỉ mục của lần xuất hiện đầu tiên của chuỗi con được cung cấp trong chuỗi.

Copied!
string = 'bobby-hadz-com'

print(string.index('-'))  # 👉️ 5

Chúng tôi đã sử dụng cắt chuỗi để có được một phần của chuỗi trước ký tự đã cho.

Cú pháp để cắt chuỗi là

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

0.

Chỉ số

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

1 bao gồm, trong khi chỉ số

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

2 là độc quyền (lên đến, nhưng không bao gồm).

Các chỉ mục Python là dựa trên 0, do đó, ký tự đầu tiên trong một chuỗi có chỉ số

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)

6 và ký tự cuối cùng có chỉ số là

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

4 hoặc

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

5.

Slice

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

6 bắt đầu tại INDEX

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)

6 và đi lên, nhưng không bao gồm chỉ mục được chỉ định.

Bạn có thể sử dụng toán tử bổ sung (+) nếu bạn cần thêm ký tự vào chuỗi.

Copied!
string = 'bobby-hadz-com'

character = '-'

before_character = string[:string.index(character)] + character
print(before_character)  # 👉️ 'bobby-'

Phương thức

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

8 tăng

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

9 nếu không tìm thấy chuỗi con trong chuỗi.

Bạn có thể sử dụng câu lệnh

Copied!
string = 'bobby-hadz-com'

character = '-'

before_character = string.split(character, 1)[0] + character
print(before_character)  # 👉️ 'bobby-'

0 để xử lý kịch bản trong đó không tìm thấy chuỗi con trong chuỗi.

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)

0

Chất nền được chỉ định không chứa trong chuỗi, do đó

Copied!
string = 'bobby-hadz-com'

# 👇️ ['bobby', 'hadz-com']
print(string.split('-', 1))

before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

9 được nâng lên và sau đó được xử lý bởi khối

Copied!
string = 'bobby-hadz-com'

character = '-'

before_character = string.split(character, 1)[0] + character
print(before_character)  # 👉️ 'bobby-'

2.

Cách tiếp cận mà bạn chọn là một vấn đề sở thích cá nhân. Tôi sẽ sử dụng phương pháp

Copied!
string = 'bobby-hadz-com'


# ✅ Get part of string before FIRST occurrence of character
before_character = string.split('-', 1)[0]
print(before_character)  # 👉️ 'bobby'

# -----------------------------------------------------

# ✅ Get part of string before LAST occurrence of character
before_character = string.rsplit('-', 1)[0]
print(before_character)  # 👉️ bobby-hadz

8 vì tôi thấy nó trực tiếp và trực quan hơn.

Làm thế nào để bạn có được một chuỗi trước một chuỗi con cụ thể?

Sử dụng phương thức Subring () để có được chuỗi con trước một ký tự cụ thể, ví dụ:const trước = str.chuỗi con (0, str. indexof ('_'));.Phương thức chuỗi con sẽ trả về một chuỗi mới chứa phần của chuỗi trước ký tự được chỉ định., e.g. const before = str. substring(0, str. indexOf('_')); . The substring method will return a new string containing the part of the string before the specified character.

Làm thế nào để bạn trích xuất một chuỗi từ một chuỗi trong Python?

Bạn có thể trích xuất một chuỗi con trong phạm vi bắt đầustart <= x < stop with [start:step] . If start is omitted, the range is from the beginning, and if end is omitted, the range is to the end. You can also use negative values. If start > end , no error is raised and an empty character '' is extracted.

Làm thế nào để bạn cắt một chuỗi trước một ký tự cụ thể trong Python?

Để xóa mọi thứ trước một ký tự trong một chuỗi:..

Sử dụng str.tìm () phương thức để lấy chỉ mục của ký tự ..

Sử dụng cắt chuỗi và đặt chỉ mục bắt đầu thành chỉ mục của ký tự ..

Chuỗi mới sẽ không chứa các ký tự trước ..

Làm cách nào để tìm thứ tự của một chuỗi trong Python?

Chuỗi python find () Phương thức find () trả về chỉ số xuất hiện đầu tiên của chuỗi con (nếu tìm thấy).Nếu không tìm thấy, nó trả về -1.find() The find() method returns the index of first occurrence of the substring (if found). If not found, it returns -1.

programming python Split set python Get string Python

Hướng dẫn how do you get a string before a specific string in python? - làm cách nào để lấy một chuỗi trước một chuỗi cụ thể trong python?

TLDR

Mã số

Kết quả

Nhận một phần của chuỗi trước một ký tự cụ thể trong Python #

Nhận một phần của chuỗi trước một ký tự cụ thể bằng cách sử dụng str.index () #

Làm thế nào để bạn có được một chuỗi trước một chuỗi con cụ thể?

Làm thế nào để bạn trích xuất một chuỗi từ một chuỗi trong Python?

Làm thế nào để bạn cắt một chuỗi trước một ký tự cụ thể trong Python?

Làm cách nào để tìm thứ tự của một chuỗi trong Python?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội