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.

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 spetsiaalne 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 " või ':

# 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 indeksil 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; -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

Tip

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 lingid selgitamaks, mis on muutumatute (immutable) ja muutuvate (mutable) objektide vahe:

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 sisse ehitatud 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"

Kõike ei jõua siin vaadata, kogu nimekirja leiab siit.

Sõne vorming

Sõne sobivale formaadile viimiseks on Pythonis mitu võimalust. Lihtsamate operatsioonide nagu kahe sõne ühendamiseks võib kasutada + operaatorit, kuid keerulisemate operatsioonide jaoks tasub kasutada sobivat vormindamise tööriista. Esialgu toimus Pythonis keerulisem vormindamine % operaatori abil, kuid nüüd on uueks vormindamise stiiliks .format() ja f string. Tasub valida üks uuem stiil ja keskenduda sellele, kuid teada võiks kõiki, sest teiste koodidest võib leida teises stiilis sõne vormindamist.

Lihtne näide erinevatest vormingu viisidest. Mõni on paindlikum kui teine, kuid igale ühele 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'

Täisarvud

>>> "My integer: {:d}".format(15)
'My integer: 15'

Ujukomaarvud

>>> "My float: {:f}".format(3.141592)
'My float: 3.141592'

Paremale joondamine

>>> "{:>20}".format("hello")
'               hello'

Vasakule joondamine

>>> "{:20}".format("hello")
'hello               '

Joondamisel tühikust erineva sümboli kasutamine

>>> "{:-<20}".format("hello")
'hello---------------'

Keskele joondamine

>>> "{:^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'

Nimeline kohatäide

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 (Python 3.6) f strings kujul. Üldiselt töötab see 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 veendu enne, et sul on installeeritud piisavalt värske Pythoni versioon.

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#

Saab kasutada mistahes legaalset Pythoni avaldist

def foo():
    return 25

print(f"result = {foo()}")  # -> result = 25

Vormingu täpsustamine 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

Nullidega täitmine

n = 5
print(f"{n:02}") # -> 05

a = 22
print(f"{a:05}")  # -> 00022

Lisalugemine - Vormindamise stiil: %

Vorming % operaatoriga.

Danger

See pärineb Python 2-st, nüüd peetakse seda vanaks stiiliks ja tahetakse tulevikus üldse eemaldada. Eelista .format() või f string.

Lihtne näide

>>> "%s %d" % ("age", 20)
'age 20'

Täisarvud

>>> "%d" % 15
'15'

Ujukomaarvud

>>> "%f" % 3.141592
'3.141592'

Rohkem lugemist