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 see 1 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:

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"

in

not in

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

len()

leiab sõne pikkuse

len("bacon")

len("abc 123")

5

7

int()

teisendab sõne int

andmetüübiks

int("30")

type(int("2"))

30

<class 'int'>

float()

teisendab sõne float

andmetüübiks

float("125.5")

type(float("2.8"))

125.5

<class 'float'>

str()

teisendab objekti str

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

.capitalize()

tagastab sõne,

kus esimene täht on suur

ja teised väikesed

"pythON".capitalize()

"banana".capitalize()

"leMon".capitalize()

"Python"

"Banana"

"Lemon"

.upper()

asendab sõnes

kõik tähed suurtega

"pythON".upper()

"banana".upper()

"PYTHON"

"BANANA"

.lower()

asendab sõnes

kõik tähed väikestega

"pythON".lower()

"BANANA".lower()

"python"

"banana"

.swapcase()

muudab sõnes

suured tähed väikesteks

ja vastupidi

"pythON".swapcase()

"leMon".swapcase()

"banana".swapcase()

"PYTHon"

"LEmON"

"BANANA"

.center()

.ljust()

.rjust()

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"

.count()

tagastab sõnes olevate

mitte kattuvate

alamsõnade arvu

"bobobob".count("bob")

"bobobob".count("BOB")

"bobobob".count("o")

2

0

3

.startswith()

.endswith()

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

.find()

.index()

tagastavad mõlemad

esimese leitud

alamsõne indeksi, kui

elementi ei leia,

siis .find()

tagastab -1,

aga index annab

ValueError-i

"pythON".find("y")

"pythON".find("z")

"pythON".find("N")

"pythON".index("n")

1

-1

5

ValueError: substring not found

.isalpha()

tagastab True,

kui kõik märgid sõnes on

tähed

"pythON".isalpha()

"abc123".isalpha()

"pythON!".isalpha()

True

False

False

.islower()

tagastab True,

kui kõik tähed sõnes on

väiketähed

"abc123".islower()

"abc123?".islower()

"pythON".islower()

True

True

False

.isupper()

tagastab True,

kui kõik tähed sõnes on

suurtähed

"UPPER".isupper()

"UPPEr".isupper()

"pythON".isupper()

True

False

False

.isdigit()

tagastab True,

kui kõik märgid sõnes on

numbrid

"55".isdigit()

"abc123".isdigit()

"12.5".isdigit()

True

False

False

.isdecimal()

tagastab True,

kui kõik märgid sõnes on

kümnendarvud

"55".isdecimal()

"12.5".isdecimal()

"A".isdecimal()

True

False

False

.split()

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

.join()

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"

.strip()

.lstrip()

.rstrip()

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