Forberedelse til kodeinterviews · Lektion

Pythons string-API til interviews

Arbejd med mønstre for split, join, replace, find, ord/chr og strengformatering, som optræder i interviewopgaver om parsing og transformation.

Lektion 1 af 413 trin

Pythons string-API til interviews er en gratis Forberedelse til kodeinterviews-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Forberedelse til kodeinterviews, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Forberedelse til kodeinterviews-kurset indeholder 4 lektioner i alt.

Strenge er uforanderlige i Python

Python-strenge er uforanderlige — du kan ikke ændre et tegn direkte i strengen. Alle strengoperationer, der ser ud til at ændre en streng, opretter faktisk en ny. Derfor udløser s[0] = 'X' en TypeError. Når du har brug for at ændre en streng direkte, skal du først konvertere den til en liste med tegn, udføre arbejdet og derefter bruge ''.join(chars) til at opbygge strengen igen. Dette er standardmønsteret i jobsamtaleopgaver om ændring af strenge.

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() og join(): Opdeling og opbygning

s.split(sep) opdeler en streng ved et skilletegn og returnerer en liste med delstrenge. sep=None (standardindstillingen) opdeler ved alle blanktegn og fjerner tomme strenge — ideelt til fortolkning af inddata, der er adskilt af mellemrum. 'sep'.join(iterable) sammenkæder strenge med et skilletegn mellem dem. Mønstret ' '.join(words) er den effektive måde at opbygge en streng med mellemrum mellem ordene fra en liste — brug aldrig + i en løkke.

# 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() og in

s.find(sub) returnerer indekset for den første forekomst af sub eller -1, hvis den ikke blev fundet. s.index(sub) gør det samme, men udløser ValueError, hvis delstrengen mangler — foretræk find i jobsamtalekode for at undgå uhåndterede undtagelser. Operatoren in til strenge udfører søgning efter delstrenge i O(n×m), ligesom find. Brug de valgfri parametre start og end til at søge i et udsnit uden at kopiere det.

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() og metoder til store og små bogstaver

s.replace(old, new, count=-1) returnerer en ny streng, hvor alle forekomster eller de første count forekomster er erstattet. s.strip() fjerner blanktegn i begyndelsen og slutningen eller bestemte tegn, hvis de angives. Metoderne til store og små bogstaver, lower(), upper(), capitalize() og swapcase(), opretter nye strenge — husk returværdierne, for metoderne ændrer ikke strengen. Normalisering af store og små bogstaver før sammenligning er afgørende i problemer, hvor der ikke skelnes mellem store og små bogstaver.

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() og isalnum()

Prædikatmetoder til strenge returnerer boolske værdier og kører i O(k), hvor k er mønsterets længde. s.startswith(prefix) og s.endswith(suffix) accepterer tupler med flere alternativer. s.isalpha(), s.isdigit(), s.isalnum() og s.isspace() tester tegngrupper. De bruges i jobsamtaleopgaver om gyldige palindromer, gyldige tal og fortolkning af URL'er.

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() og ASCII-aritmetik

ord(c) returnerer Unicode-kodepunktet for tegnet c. chr(n) konverterer et heltal tilbage til et tegn. For små bogstaver giver ord(c) - ord('a') værdierne 0-25 — en enkel måde at opbygge frekvensarrays med fast størrelse 26 uden en hash-tabel, hvilket i praksis er hurtigere for det engelske alfabet. Denne teknik optræder i anagram- og palindromopgaver.

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)

Strengformatering af resultat

I programmeringsjobsamtaler kan et overskueligt resultat være vigtigt. Python tilbyder tre formateringsstile: %-formatering (gammel), .format() (klassisk) og f-strenge (moderne og foretrukne). F-strenge er de mest læsbare og understøtter udtryk direkte: f'{value:.2f}' formaterer et kommatal med 2 decimaler. Hvis du hurtigt kan formatere tal, udfylde strenge og udskrive tabeller, bruger du mindre tid på fejlfinding under tidspres.

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'

Effektiv opbygning af strenge med join()

Strengsammenkædning med + i en løkke opretter en ny streng i hver iteration, hvilket samlet koster O(n²) for n tegn. Det korrekte mønster er at føje delene til en liste og kalde ''.join(parts) til sidst, hvilket kører i O(n). Dette er et af de mest almindelige ydelsesantimønstre i Python. Hvis du nævner dette kompromis i en jobsamtale, viser du, at du forstår Pythons hukommelsesmodel.

# 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'

Fortolkning af heltal og kommatal fra strenge

Konvertering mellem strenge og tal er grundlæggende i problemer om fortolkning. int(s) og float(s) fortolker numeriske strenge; de udløser ValueError ved ugyldige inddata. Brug en try-except-blok for en mere sikker fortolkning. Strengmetoderne isdigit() og isnumeric() kan forhåndsvalidere inddata før konverteringen. Problemer som »atoi« (streng til heltal) kræver håndtering af indledende mellemrum, fortegn og overflow.

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

Strengudsnit i algoritmeproblemer

Strengudsnit bruges konstant, men de har skjulte omkostninger: s[i:j] opretter en ny streng med længden j-i i O(j-i)-tid. Når du skal sende delstrenge til rekursive funktioner, kan du i stedet sende indekserne (start, end) for at undgå allokeringsomkostningen på O(n²) ved at oprette nye strenge. Denne optimering er vigtig i problemer som længste palindromiske delstreng, hvor mange delstrenge testes.

# 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

Hurtigreference til strengjobsamtaler

Hav disse strengmetoder klar i hukommelsen til jobsamtaler:

split / join — opdeling og sammenføjning
strip / lstrip / rstrip — fjern blanktegn
lower / upper — normalisér store og små bogstaver
find / index — lokalisér delstrenge
replace — erstatninger
isalnum / isalpha / isdigit — tjek af tegnklasser
ord / chr — ASCII-beregninger til problemer med et fast alfabet
startswith / endswith — præfiks- og suffikstjek

# 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

Hurtigt tjek

Tjek din forståelse af begreberne i Data Structures & Algorithms — Coding Interview Prep fra denne lektion.

Besvar den i den interaktive lektion

Lektionsopsamling

I denne lektion lærte du: Python-strenge kan ikke ændres — ændringer kræver, at du konverterer til en liste, ændrer den og derefter sammenføjer elementerne igen, ord/chr gør det muligt at bruge frekvenstabeller med fast størrelse på 26 til problemer med små bogstaver, hvilket er hurtigere end hash-tabeller for alfabeter med begrænset størrelse, og det koster O(n²) at bygge strenge med + i en løkke — saml altid elementerne i en liste, og brug ''.join() til sidst for O(n). Nu skal vi se på teknikken med glidende vindue til delstrengsproblemer.

Gratis at komme i gang

Lær Forberedelse til kodeinterviews med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 90
Lektioner: 360

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Pythons string-API til interviews” gratis?

Ja — hele teksten til “Pythons string-API til interviews” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Forberedelse til kodeinterviews-kurset, skal du opgradere til CoddyKit PRO. Forberedelse til kodeinterviews-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Pythons string-API til interviews”?

Arbejd med mønstre for split, join, replace, find, ord/chr og strengformatering, som optræder i interviewopgaver om parsing og transformation. Du øver dig i Forberedelse til kodeinterviews med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Forberedelse til kodeinterviews?

Der kræves ingen tidligere erfaring. Forberedelse til kodeinterviews på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Pythons string-API til interviews”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Forberedelse til kodeinterviews-lektion?

Ja. Alle Forberedelse til kodeinterviews-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Forberedelse til kodeinterviews