Sõne (string)
Sõne ehk string on andmetüüp Pythonis, mida kasutatakse teksti esitamiseks. Sõne kirja panemiseks kasutame ülakomasid või jutumärke. Mitmerealine sõne tuleb piiritleda kolmekordsete jutumärkidega.
Pythonis on sõne tüübi tähistuseks str
.
Vaata ka ülevaatlikut videot sõne kohta:
Sõne loomine
# Quotation marks
str_quotes = "hello"
# Apostrophes ???
str_commas = 'ABC'
# Triple quotes.
str_triple = """
_____ _ _
| __ \ | | | |
| |__) |_ _ | |_ | |__ ___ _ ___
| ___/| | | || __|| '_ \ / _ \ | '_' |
| | | |_| || |_ | | | || (_) || | | |
|_| \__, | \__||_| |_| \___/ |_| |_|
__/ |
|___/
"""
Kui tekstis on ülakomasid, siis tasub sõne piiritleda jutumärkidega ja vastupidi.
Langkriips (\
) on spetsiaalse tähendusega sümbol, mille kasutamine ülakoma või jutumärgi ees annab Pythonile teada, et tegemist pole veel teksti lõpuga.
Näiteks vaatame, kuidas luua sõne, milles on kahekordsed või ühekordsed jutumärgid:
# no pec
# You can also edit this code
str1 = 'Bell UH-1 "Huey" Iroquois'
print(str1) # -> Bell UH-1 "Huey" Iroquois
str2 = "Bell UH-1 'Huey' Iroquois"
print(str2) # -> Bell UH-1 'Huey' Iroquois
str3 = "Bell UH-1 \"Huey\" Iroquois"
print(str3) # -> Bell UH-1 "Huey" Iroquois
Reavahetust kirjeldab sõne sees \n
. Kui on vaja langkriipsu ennast,
siis tuleb kasutada topeltlangkriipsu \\
.
# no pec
str4 = "To understand what recursion is,\nyou must first understand recursion."
print(str4) # -> To understand what recursion is,
# you must first understand recursion.
str5 = "C:\\dev\\string.py"
print(str5) # -> C:\dev\string.py
Operatsioonid sõnedega
Tekstitöötlus on tihti väga olulisel kohal ja seetõttu on Pythonis palju võimalusi tekstiga opereerimiseks. Allpool on esile toodud enamkasutatavad operatsioonid.
Sõnedest on võimalik saada üksikuid elemente []
operaatoriga ja alamsõnede jaoks on tähistus [start:stop:step]
.
Esimese tähe indeks on sõnes 0
ja viimane indeksil len(string) - 1
.
[start]
indeks, kust alustada tükeldamist, selle ärajätmisel eeldab Python, et tükeldamine algab algusest[stop]
elemendi indeks, kus peatuda, seda elementi ei arvata vahemikku, ärajätmisel tükeldatakse lõpuni[step]
sammu suurus itereerimisel, vaikimisi on see1
ning-1
itereerib elemendid tagurpidi
# no pec
str1 = "Python String"
# Single character with slice notation, element at index 3 is excluded.
print(str1[2:3]) # -> t
# Notation for getting a single character.
print(str1[2]) # -> t
# Use negative numbers to get characters from the end.
print(str1[-1]) # -> g
# Range of elements between index 0 and index 2, element at index 2 is excluded
print(str1[0:2]) # -> Py
# [start] can be omitted.
print(str1[:2]) # -> Py
# [stop] can be omitted.
print(str1[2:]) # -> thon String
# Range of elements from index 2 to the end.
print(str1[2:len(str1)]) # -> thon String
# Last three characters.
print(str1[-3:]) # -> ing
# Slicing from start to end, easy way to make a copy.
print(str1[:]) # -> Python String
# By choosing [step] to be -1, we get the reverse of original.
print(str1[::-1]) # -> gnirtS nohtyP
**Hea teada: **Olemasolevat sõne saab muuta ainult uue sõne loomisega, sest sõne on muutumatu (immutable) andmetüüp.
# no pec
aircraft = "Douglas DC-3"
# Reassigning a new string to variable. The previous value is deleted.
aircraft = "Hawker Hurricane"
print(aircraft) # -> Hawker Hurricane
supermarine = "Supermarine Spitfire"
supermarine_new = supermarine[:12] + "Seafire"
print(supermarine) # -> Supermarine Spitfire
print(supermarine_new) # -> Supermarine Seafire
supermarine.upper()
print(supermarine) # -> Supermarine Spitfire
supermarine = supermarine.upper() # Reassigning a new string to variable.
print(supermarine) # -> SUPERMARINE SPITFIRE
- Soovitatavad liselugemise lingid selgitamaks, mis on muutumatute (immutable) ja muutuvate (mutable) objektide vahe:
Artikkel "Mutable vs Immutable Data Types in Python"
Artikkel "Python Basics: Mutable vs Immutable Objects"
Alljärgnevas tabelis toome välja olulisemad operatsioonid sõnedega koos näidetega.
Operaator |
Info |
Näide |
Tulemus |
---|---|---|---|
|
ühendab sõned |
"hel" + "lo" |
"hello" |
|
lubab sõnet korrata |
"Hello" * 3 "Z" * 10 |
"HelloHelloHello" "ZZZZZZZZZZ" |
|
lubavad kontrollida kuuluvust sõnesse |
"H" in "Hello" "Hi" in "Hello" "He" not in "Hello" "a" not in "Hello" "h" not in "Hello" |
True False False True True |
|
leiab sõne pikkuse |
len("bacon") len("abc 123") |
5 7 |
|
teisendab sõne andmetüübiks |
int("30") type(int("2")) |
30 <class 'int'> |
|
teisendab sõne andmetüübiks |
float("125.5") type(float("2.8")) |
125.5 <class 'float'> |
|
teisendab objekti andmetüübiks |
str(500) str(125.5) type(str(12.4)) |
"500" "125.5" <class 'str'> |
Sõne sisseehitatud meetodid
Pythonis on sõnel olemas mitu kasulikku sisseehitatud meetodit. Vaatame näiteid peamiste kohta.
Meetod |
Info |
Näide |
Tulemus |
---|---|---|---|
|
tagastab sõne, kus esimene täht on suur ja teised väikesed |
"pythON".capitalize() "banana".capitalize() "leMon".capitalize() |
"Python" "Banana" "Lemon" |
|
asendab sõnes kõik tähed suurtega |
"pythON".upper() "banana".upper() |
"PYTHON" "BANANA" |
|
asendab sõnes kõik tähed väikestega |
"pythON".lower() "BANANA".lower() |
"python" "banana" |
|
muudab sõnes suured tähed väikesteks ja vastupidi |
"pythON".swapcase() "leMon".swapcase() "banana".swapcase() |
"PYTHon" "LEmON" "BANANA" |
|
tagastavad joondatud sõne kuhu saab lisada teise parameetrina täitesümboli; täitesümboli puudumisel täidetakse sõne tühikutega |
"pythON".center(10, "-") "pythON".center(10) "pythON".center(20, "-") "pythON".ljust(10) "pythON".ljust(10, "3") "pythON".rjust(10) "pythON".rjust(10, "p") |
"--pythON--" " pythON " "-------pythON-------" "pythON " "pythON3333" " pythON" "pppppythON" |
|
tagastab sõnes olevate mitte kattuvate alamsõnade arvu |
"bobobob".count("bob") "bobobob".count("BOB") "bobobob".count("o") |
2 0 3 |
|
tagastavad tõeväärtuse vastavalt sellele, kas sõne algab mingi eesliitega või lõppeb mingi järelliitega |
"bobobob".startswith("bo") "bobobob".startswith("boo") "bobobob".startswith("Bo") "bobobob".endswith("b") "bobobob".endswith("bo") |
True False False True False |
|
tagastavad mõlemad esimese leitud alamsõne indeksi, kui elementi ei leia, siis tagastab aga
|
"pythON".find("y") "pythON".find("z") "pythON".find("N") "pythON".index("n") |
1 -1 5 ValueError: substring not found |
|
tagastab kui kõik märgid sõnes on tähed |
"pythON".isalpha() "abc123".isalpha() "pythON!".isalpha() |
True False False |
|
tagastab kui kõik tähed sõnes on väiketähed |
"abc123".islower() "abc123?".islower() "pythON".islower() |
True True False |
|
tagastab kui kõik tähed sõnes on suurtähed |
"UPPER".isupper() "UPPEr".isupper() "pythON".isupper() |
True False False |
|
tagastab kui kõik märgid sõnes on numbrid |
"55".isdigit() "abc123".isdigit() "12.5".isdigit() |
True False False |
|
tagastab kui kõik märgid sõnes on kümnendarvud |
"55".isdecimal() "12.5".isdecimal() "A".isdecimal() |
True False False |
|
loob sõnadest listi mingi kindla eraldaja alusel (vaikimisi on eraldajaks tühik teise parameetrina saab lisada lahknemiste arvu |
"an example sentence".split() "14-22-2017".split("-") """text on several lines""".split("\n") "127.0.0.1".split(".", 1) |
['an', 'example', 'sentence'] ['14', '22', '2017'] ['text', 'on several', 'lines'] ['127', '0.0.1'] |
|
liidab elementide jada kokku üheks sõneks |
" ".join(["a", "b", "c"]) "-".join({"x", "y", "z"}) ", ".join(("1", "2", "3")) |
"a b c" "x-y-z" "1, 2, 3" |
|
eemaldavad vaikimisi sõne otstest tühikud, saab määrata ka muu sümboli |
" space ".strip() "www.taltech.ee".strip(".we") " space ".lstrip() "www.taltech.ee".lstrip("w.e") " space ".rstrip() "taltech.ee".rstrip(".e") "www.taltech.ee".rstrip("w.e") |
"space" "taltech" "space " "taltech.ee " space" "taltech" "www.taltech" |
Kuna sõnel on väga palju sisseehitatud meetodeid, siis kogu nimekirja leiab siit.
Sõne vorming
Sõne sobivale formaadile viimiseks on Pythonis mitu võimalust. Lihtsamateks operatsioonideks nagu näiteks kahe sõne
ühendamiseks võib kasutada +
operaatorit, kuid keerulisemate operatsioonide jaoks tasub kasutada
sobivat vormindamise tööriista. Esialgu toimus Pythonis (vanemas Python 2 versioonis) keerulisem vormindamine %
operaatori abil, kuid nüüd
on uueks vormindamise stiiliks .format()
ja f string
. Tasub valida üks uuematest vormindamiste stiilidest
ja keskenduda sellele, kuid teada võiks kõiki, sest teiste koodi lugedes võib leida teises stiilis sõne vormindamist.
Allpool on toodud lihtne näide erinevatest vorminguviisidest. Mõni on paindlikum kui teine, kuid igale variandile leiab teatud olukorras kasutust.
name = "Tim"
print("Hello " + name) # Simple concatenation.
print(" ".join(("Hello", name))) # Hacky method using .join.
print("Hello %s" % name) # Using "%" style.
print("Hello {}".format(name)) # Using ".format()" style.
print(f"Hello {name}") # Using "f string" style.
# Output of all above: "Hello Tim".
Vormindamise stiil: .format()
Vorming .format()
meetodiga.
Lihtne näide:
>>> "{} {}".format("age", 20)
'age 20'
>>> "{1} {0}".format("age", 20)
'20 age'
Näide täisarvudega:
>>> "My integer: {:d}".format(15)
'My integer: 15'
Näide ujukomaarvudega:
>>> "My float: {:f}".format(3.141592)
'My float: 3.141592'
Näide paremale joondamisest:
>>> "{:>20}".format("hello")
' hello'
Näide vasakule joondamisest:
>>> "{:20}".format("hello")
'hello '
Joondamisel tühikust erineva sümboli kasutamine:
>>> "{:-<20}".format("hello")
'hello---------------'
Näide keskele joondamisest:
>>> "{:^20}".format("hello")
' hello '
Sõne kärpimine:
>>> "{:.7}".format("longstring")
'longstr'
Numbrite laiuse ja täpsuse valimine:
>>> "{:3d}".format(15)
' 15'
>>> "{:07.3f}".format(3.141592)
'003.142'
>>> "{:03d}".format(15)
'015'
Näide nimelisest kohatäitest:
vocations = "{tim} and {alice}".format(tim="Software Architect", alice="Graphic Designer")
print(vocations) # -> Software Architect and Graphic Designer
jobs = {"Tim": "Software Architect", "Alice": "Graphic Designer"}
print("Jobs: {Tim}, {Alice}".format(**jobs)) # -> Jobs: Software Architect, Graphic Designer
Erinevate andmestruktuuride kasutamine:
data = {"apple": 22, "pear": 17}
print("{d[apple]} {d[pear]}".format(d=data)) # -> 22 17
languages = ["Python", "Java", "Javascript", "C#", "C++", "Swift"]
print("{l[4]}, {l[5]}".format(l=languages)) # -> C++, Swift
Vormindamise stiil: f string
Vorming uue f string
kujul töötab see üldjoontes täpselt samamoodi nagu .format()
, kus peamiseks erinevuseks on see,
et muutujaid saab sisestada otse sõnesse. See väldib koodi dubleerimist ja suurendab loetavust.
Selle kasutamiseks tuleks enne veenduda, et on installeeritud piisavalt värske Pythoni versioon.
Vaata alljärgnevat videot sõne vormindamise kohta:
All on toodud näide, kuidas kasutada sõnes muutuja väärtusi, kasutades selleks f string
vormingut.
name = "Alice"
age = 31
print(f"Her name is {name} and she is {age} years old.") # -> Her name is Alice and she is 31 years old.
languages = ["Python", "Java", "Javascript", "C#", "C++", "Swift"]
print(f"{languages[0]}, {languages[3]}") # -> Python, C#
Näide, kuidas vormingut täpsustada avaldistega:
import math
width = 10
precision = 6
print(f"The value of tau is {(math.pi * 2):{width}.{precision}}") # -> The value of tau is 6.28319
Näide nullidega täitmisest:
n = 5
print(f"{n:02}") # -> 05
a = 22
print(f"{a:05}") # -> 00022
Lisalugemine - Vormindamise stiil: %
Vorming %
operaatoriga.
Oluline! See vormindalise stiil pärineb Python 2-st ning nüüd peetakse seda vanaks stiiliks ja tahetakse tulevikus üldse eemaldada. Eelista .format() või f string vormindamist.
Lihtne näide vormindamisest %
operaatoriga:
>>> "%s %d" % ("age", 20)
'age 20'
Täisarvude vormindamine:
>>> "%d" % 15
'15'
Ujukomaarvude vormindamine:
>>> "%f" % 3.141592
'3.141592'
Rohkem lugemist
Pythoni ametlik dokumentatsioon sõne ja selle meetodite kohta.
Sõnede peatükk TLÜ programmeerimise digiõpikus.
Real Python - "Strings and Character Data in Python": põhjalik ülevaade sõnest
W3Schools - "Python String Methods": sõne meetodid koos interaktiivsete näidetega
Pythoni ametlik dokumentatsioon vormindamise stiili
f string
kohta.Pythoni ametlik dokumentatsioon vormindamise stiili
.format()
kohta.