Persediaan Temu Duga Pengaturcaraan · Pelajaran

API Rentetan Python untuk Temu Duga

Pelajari split, join, replace, find, ord/chr dan corak pemformatan rentetan yang muncul dalam masalah temu duga berkaitan penghuraian dan transformasi.

Pelajaran 1 daripada 413 langkah

API Rentetan Python untuk Temu Duga ialah pelajaran Persediaan Temu Duga Pengaturcaraan percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Persediaan Temu Duga Pengaturcaraan, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Persediaan Temu Duga Pengaturcaraan merangkumi sejumlah 4 pelajaran.

Rentetan Tidak Boleh Diubah dalam Python

Rentetan Python adalah tidak boleh diubah — Anda tidak boleh menukar aksara secara setempat. Setiap operasi rentetan yang kelihatan seperti mengubah rentetan sebenarnya mencipta rentetan baharu. Ini bermakna s[0] = 'X' menimbulkan TypeError. Apabila Anda memerlukan manipulasi secara setempat, tukarkan rentetan kepada senarai aksara terlebih dahulu, lakukan kerja Anda, kemudian gunakan ''.join(chars) untuk membinanya semula. Ini ialah corak temu duga standard bagi masalah pengubahan rentetan.

s = 'hello'
# s[0] = 'H'  # TypeError!

# In-place mutation pattern:
chars = list(s)
chars[0] = 'H'
result = ''.join(chars)
print(result)  # 'Hello'

# Reversing a string
print(s[::-1])           # 'olleh'
print(''.join(reversed(s)))  # 'olleh'

split() dan join(): Menghurai dan Membina

s.split(sep) memisahkan rentetan berdasarkan pembatas dan mengembalikan senarai subrentetan. sep=None (lalai) memisahkan berdasarkan sebarang ruang putih dan membuang rentetan kosong — sesuai untuk menghuraikan masukan yang dipisahkan oleh ruang. 'sep'.join(iterable) menggabungkan rentetan dengan pemisah di antaranya. Idiom ' '.join(words) ialah cara cekap untuk membina rentetan yang dipisahkan ruang daripada senarai — jangan sekali-kali gunakan + dalam gelung.

# split
sentence = '  hello   world  '
words = sentence.split()    # ['hello', 'world']
print(words)

csv = 'a,b,c,d'
parts = csv.split(',')      # ['a', 'b', 'c', 'd']
print(parts)

# join
print(' '.join(words))      # 'hello world'
print(','.join(['x','y','z']))  # 'x,y,z'

# Reverse words in a sentence
print(' '.join(sentence.split()[::-1]))  # 'world hello'

find(), index(), dan in

s.find(sub) mengembalikan indeks kemunculan pertama sub, atau -1 jika tidak ditemui. s.index(sub) melakukan perkara yang sama tetapi menimbulkan ValueError jika tiada — utamakan find dalam kod temu duga untuk mengelakkan pengecualian yang tidak dikendalikan. Operator in untuk rentetan ialah carian subrentetan O(n×m), sama seperti find. Gunakan parameter start dan end pilihan untuk mencari dalam kepingan tanpa menyalin.

s = 'abcabcabc'
print(s.find('bc'))          # 1  (first occurrence)
print(s.find('bc', 2))       # 4  (search from index 2)
print(s.find('xyz'))         # -1 (not found)
print('abc' in s)            # True

# Count occurrences manually
count = 0
start = 0
while True:
    idx = s.find('bc', start)
    if idx == -1: break
    count += 1
    start = idx + 1
print(count)  # 3

replace(), strip(), dan Kaedah Huruf Besar-Kecil

s.replace(old, new, count=-1) mengembalikan rentetan baharu dengan semua kemunculan (atau kemunculan pertama sebanyak count) digantikan. s.strip() membuang ruang putih di awal dan akhir (atau aksara yang ditentukan). Kaedah huruf besar-kecil lower(), upper(), capitalize(), dan swapcase() mencipta rentetan baharu — ingat nilai pulangannya kerana kaedah ini tidak mengubah rentetan asal. Menyeragamkan huruf besar-kecil sebelum perbandingan adalah penting untuk masalah yang tidak peka huruf besar-kecil.

s = '  Hello, World!  '
print(s.strip())          # 'Hello, World!'
print(s.strip().lower())  # 'hello, world!'

print('banana'.replace('a', 'o'))   # 'bonono'
print('banana'.replace('a', 'o', 2)) # 'bonona'

# Normalise for comparison
def same_ignoring_case(a, b):
    return a.lower() == b.lower()

print(same_ignoring_case('Racecar', 'racecar'))  # True

startswith(), endswith(), dan isalnum()

Kaedah rentetan predikat mengembalikan nilai benar atau palsu dan mempunyai kerumitan O(k), dengan k ialah panjang corak. s.startswith(prefix) dan s.endswith(suffix) menerima tupel untuk beberapa pilihan. s.isalpha(), s.isdigit(), s.isalnum(), dan s.isspace() menguji kelas aksara. Kaedah ini digunakan dalam masalah temu duga palindrom sah, nombor sah dan penghuraian URL.

print('hello'.startswith('hel'))   # True
print('hello'.endswith(('lo', 'la')))  # True

# isalnum for palindrome filtering
def clean(s):
    return ''.join(c.lower() for c in s if c.isalnum())

print(clean('A man, a plan, a canal: Panama'))
# 'amanaplanacanalpanama'
print(clean('123abc!@#'))
# '123abc'

ord(), chr(), dan Aritmetik ASCII

ord(c) mengembalikan titik kod Unicode bagi aksara c. chr(n) menukarkan integer kembali kepada aksara. Untuk huruf kecil, ord(c) - ord('a') memberikan 0-25 — cara yang kemas untuk membina tatasusunan kekerapan bersaiz tetap 26 tanpa peta cincang, yang lebih pantas dalam amalan untuk abjad Inggeris. Teknik ini muncul dalam masalah anagram dan palindrom.

print(ord('a'))   # 97
print(ord('z'))   # 122
print(chr(65))    # 'A'

# Frequency array for lowercase letters
def char_freq(s):
    freq = [0] * 26
    for c in s:
        freq[ord(c) - ord('a')] += 1
    return freq

print(char_freq('anagram'))  # [3,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0]
# index 0='a'(3), 6='g'(1), 12='m'(1), 17='r'(1)

Pemformatan Rentetan untuk Keluaran

Dalam temu duga pengekodan, keluaran yang kemas kadangkala penting. Python menawarkan tiga gaya pemformatan: pemformatan % (lama), .format() (klasik), dan rentetan-f (moden serta diutamakan). Rentetan-f paling mudah dibaca dan menyokong ungkapan secara langsung: f'{value:.2f}' memformat nombor titik apung kepada 2 tempat perpuluhan. Mengetahui cara memformat nombor, mengisi rentetan dan mencetak jadual dengan cepat dapat mengurangkan masa penyahpepijatan apabila berada di bawah tekanan.

name = 'Alice'
score = 95.678

# f-string (preferred in interviews)
print(f'{name}: {score:.1f}')      # Alice: 95.7
print(f'{name:>10}: {score:05.1f}') # right-align

# Zero-pad an integer
print(f'{42:04d}')   # 0042

# Join and format a list
nums = [1, 2, 3, 4]
print(', '.join(str(n) for n in nums))  # '1, 2, 3, 4'

Pembinaan Rentetan Cekap dengan join()

Penggabungan rentetan dengan + dalam gelung mencipta rentetan baharu pada setiap lelaran, dengan kos keseluruhan O(n²) untuk n aksara. Corak yang betul ialah: tambahkan bahagian kepada senarai dan panggil ''.join(parts) pada akhir, yang mengambil O(n). Ini ialah salah satu antipola prestasi Python yang paling biasa. Dalam temu duga, menyebut pertukaran ini menunjukkan bahawa Anda memahami model memori Python.

# SLOW: O(n^2) due to repeated string allocation
def build_bad(chars):
    s = ''
    for c in chars:
        s += c  # creates a new string each time!
    return s

# FAST: O(n)
def build_good(chars):
    parts = []
    for c in chars:
        parts.append(c)
    return ''.join(parts)  # single allocation

# Or even more concise:
def build_best(chars):
    return ''.join(chars)

print(build_best(['h','e','l','l','o']))  # 'hello'

Menghurai Nombor Bulat dan Perpuluhan daripada Rentetan

Penukaran antara rentetan dan nombor adalah asas dalam masalah penghuraian. int(s) dan float(s) menghuraikan rentetan berangka; kedua-duanya menimbulkan ValueError untuk masukan yang tidak sah. Untuk penghuraian yang lebih selamat, gunakan blok cuba-kecuali. Kaedah rentetan isdigit() dan isnumeric() mengesahkan masukan terlebih dahulu sebelum penukaran. Masalah seperti 'atoi' (rentetan kepada integer) memerlukan pengendalian ruang awal, tanda dan limpahan.

def my_atoi(s):
    s = s.lstrip()  # remove leading spaces
    if not s: return 0
    sign = 1
    idx = 0
    if s[0] in '-+':
        sign = -1 if s[0] == '-' else 1
        idx = 1
    num = 0
    while idx < len(s) and s[idx].isdigit():
        num = num * 10 + int(s[idx])
        idx += 1
    result = sign * num
    INT_MAX, INT_MIN = 2**31 - 1, -(2**31)
    return max(INT_MIN, min(INT_MAX, result))

print(my_atoi('   -42'))          # -42
print(my_atoi('4193 with words'))  # 4193

Penghirisan Rentetan dalam Masalah Algoritma

Penghirisan rentetan kerap digunakan tetapi mempunyai kos tersembunyi: s[i:j] mencipta rentetan baharu sepanjang j-i dalam masa O(j-i). Apabila Anda perlu menghantar subrentetan kepada fungsi rekursif, pertimbangkan untuk menghantar indeks (start, end), bukannya subrentetan sebenar, bagi mengelakkan overhed peruntukan O(n²). Pengoptimuman ini penting dalam masalah seperti subrentetan palindrom terpanjang yang menguji banyak subrentetan.

# Naive: O(n^3) because slicing inside nested loops
def is_palindrome_naive(s):
    return s == s[::-1]  # O(n) slice + O(n) compare

# Pass indices to avoid allocating substrings
def is_palindrome_range(s, left, right):
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1; right -= 1
    return True  # O(right-left) time, O(1) space

print(is_palindrome_range('racecar', 0, 6))  # True
print(is_palindrome_range('hello',   0, 4))  # False

Rujukan Pantas Rentetan untuk Temu Duga

Hafalkan kaedah rentetan ini untuk temu duga:

split / join — menghuraikan dan membina
strip / lstrip / rstrip — memangkas ruang putih
lower / upper — menyeragamkan huruf besar dan kecil
find / index — mencari subrentetan
replace — penggantian
isalnum / isalpha / isdigit — menyemak kelas aksara
ord / chr — aritmetik ASCII untuk masalah abjad tetap
startswith / endswith — menyemak awalan dan akhiran

# Combining methods: reverse words, preserve spaces
def reverse_words(s):
    return ' '.join(reversed(s.split()))

print(reverse_words('  hello   world  '))
# 'world hello'

# Check anagram using sorted strings
def is_anagram(s, t):
    return sorted(s) == sorted(t)

print(is_anagram('anagram', 'nagaram'))  # True
print(is_anagram('rat', 'car'))          # False

Semakan Pantas

Uji pemahaman anda tentang konsep Struktur Data & Algoritma — Persediaan Temu Duga Pengekodan daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Rumusan Pelajaran

Dalam pelajaran ini, anda mempelajari: rentetan Python tidak boleh diubah — pengubahsuaian memerlukan penukaran kepada senarai, pengubahsuaian, kemudian penyambungan semula, penukaran ordinal dan aksara membolehkan tatasusunan frekuensi bersaiz tetap sebanyak 26 untuk masalah huruf kecil, yang lebih pantas daripada peta cincang bagi abjad yang terhad, dan pembinaan rentetan menggunakan + dalam gelung berkos O(n²) — sentiasa kumpulkan rentetan dalam senarai dan gunakan ''.join() pada akhir untuk O(n). Seterusnya, kita akan meneroka teknik tetingkap gelongsor untuk masalah subrentetan.

Percuma untuk bermula

Pelajari Persediaan Temu Duga Pengaturcaraan dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 90
Pelajaran: 360

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “API Rentetan Python untuk Temu Duga” percuma?

Ya — teks penuh “API Rentetan Python untuk Temu Duga” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Persediaan Temu Duga Pengaturcaraan, tingkat taraf kepada CoddyKit PRO. Kursus Persediaan Temu Duga Pengaturcaraan merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “API Rentetan Python untuk Temu Duga”?

Pelajari split, join, replace, find, ord/chr dan corak pemformatan rentetan yang muncul dalam masalah temu duga berkaitan penghuraian dan transformasi. Anda berlatih Persediaan Temu Duga Pengaturcaraan menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Persediaan Temu Duga Pengaturcaraan?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Persediaan Temu Duga Pengaturcaraan di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “API Rentetan Python untuk Temu Duga” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Persediaan Temu Duga Pengaturcaraan ini?

Ya. Setiap pelajaran Persediaan Temu Duga Pengaturcaraan menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

API Rentetan Python untuk Temu Duga
Tetingkap Gelangsar untuk Subrentetan
Anagram dan Peta Kekerapan Aksara
Pengekodan Rentetan, Pembalikan dan Palindrom

← Kembali ke Persediaan Temu Duga Pengaturcaraan