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.

Loomine:

str_quotes = "hello"
str_commas = 'ABC'
str_triple = """
 _____         _    _
|  __ \       | |  | |
| |__) |_   _ | |_ | |__    ___   _ ___
|  ___/| | | || __|| '_ \  / _ \ | '_' |
| |    | |_| || |_ | | | || (_) || | | |
|_|     \__, | \__||_| |_| \___/ |_| |_|
         __/ |
        |___/
"""

Kui tekstis on ülakomasid, siis tasub 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. Reavahetust kirjeldab sõne sees \n. Kui on vaja langkriipsu ennast, siis tuleb kasutada topeltlangkriipsu \\.

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

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õnega:

Tekstitöötlus on tihti väga olulisel kohal ja seetõttu on Pythonis palju võimalusi tekstiga opereerimiseks. Allpool on esile toodud enamkasutatavad operatsioonid, kuid kogu nimekirja leiab

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

str1 = "Python String"

# single character with slice notation
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

# range of elements from index 2 to the end
print(str1[2:len(str1)])  # -> thon String

# [stop] can be omitted
print(str1[2:])  # -> 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

NB! Olemasolevat sõne saab muuta ainult uue sõne loomisega, sest sõne on muutumatu (immutable) andmetüüp. Uuele sõnele võib anda ka sama muutujanime. Loodud sõnet

aircraft = "Douglas DC-3"
aircraft = "Hawker Hurricane"  # reassigning a new string to variable
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()
print(supermarine)  # -> SUPERMARINE SPITFIRE
Soovitatavad lingid selgitamaks, mis on muutumatute (immutable) ja muutuvate (mutable) objektide vahe:

+ operaator ühendab sõned.

str1 = "he"
str2 = "llo"
greeting = str1 + str2  # -> "hello"

* operaator lubab sõnet korrata.

str1 = "Hello"
str2 = "Z"
print(str1 * 3)  # HelloHelloHello
print(str2 * 10)  # ZZZZZZZZZZ

in ja not in lubavad kontrollida kuuluvust sõnesse.

lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
print("d" in lorem)  # True
print("D" in lorem)  # False
print("consectetur" in lorem)  # True
print("Amet" not in lorem)  # True

Sõne pikkust saab leida funktsiooniga len().

str1 = "bacon"
print(len(str1))  # ->  5

print(len("abc 123"))  # ->  7

Sobivat sõne saab lihtsasti teisendada int või float andmetüübiks ja vastupidi.

a = "30"
a = int(a)
print(a)  # -> 30
print(type(a))  # ->  <class 'int'>

c = "125.5"
print(float(c))   # -> 125.5
print(type(float(c)))   # ->  <class 'float'>

d = 500
print(str(d))   # -> 500
print(type(str(d)))   # -> <class 'str'>

Sõne sisseehitatud funktsioonid

Pythonis on sõnel olemas mitu kasulikku sisse ehitatud funktsiooni. Vaatame näited peamiste kohta.

.capitalize() tagastab sõne, kus esimene täht on suur ja teised väikesed.

>>> snake = "pythON"
>>> snake.capitalize()
'Python'

.upper() ja .lower() asendavad sõnes kõik tähed vastavalt suurtega või väikestega. .swapcase() muudab sõnes suured tähed väikesteks ja vastupidi.

>>> snake.upper()
'PYTHON'
>>> snake.lower()
'python'
>>> snake.swapcase()
'PYTHon'

.center(), .ljust() ja .rjust() tagastavad joondatud sõne, kuhu saab lisada teise parameetrina täitesümboli. Täitesümboli puudumisel täidetakse sõne tühikutega.

>>> snake.center(10, "-")
'--pythON--'
>>> snake.ljust(10)
'pythON    '
>>> snake.rjust(10, "p")
'pppppythON'

.count() tagastab sõnes olevate mitte kattuvate alamsõnade arvu.

>>> name = "bobobob"
>>> name.count("bob")
2

.startswith() ja .endswith() tagastavad tõeväärtuse vastavalt sellele, kas sõne algab mingi eesliitega või lõppeb mingi järelliitega.

>>> name.startswith("bo")
True
>>> name.endswith("b")
True

.find() ja .index() tagastavad mõlemad esimese leitud alamsõne indeksi, kui elementi ei leia, siis .find() tagastab -1, aga index annab ValueError-i.

>>> snake.find("y")
1
>>> snake.index("y")
1
>>> snake.find("z")
-1
>>> snake.index("z")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

Erinevad kontrollfunktsioonid, mis vaatavad sõne sisu ja tagastavad sobiva tõeväärtuse.

>>> snake.isalpha()  # snake = "pythON"
True
>>> charnum = "abc123"
>>> charnum.isalpha()
False
>>> charnum.islower()
True
>>> caps = "UPPER"
>>> caps.isupper()
True
>>> num = "55"
>>> num.isdigit()
True
>>> num.isdecimal()
True
>>> flo = "12.5"
>>> charnum.isdigit()
False
>>> charnum.isdecimal()
False

.split() loob sõnadest listi mingi kindla eraldaja alusel.

>>> "an example sentence".split()
['an', 'example', 'sentence']
>>> "14-22-2017".split("-")
['14', '22', '2017']
>>> a = """some text
... on several
... different lines"""
>>> a.split("\n")
['some text', 'on several', 'different lines']
>>> "127.0.0.1".split(".", maxsplit=1)
['127', '0.0.1']

.join() liidab elementide jada kokku üheks sõneks.

>>> " ".join(["a", "b", "c"])
'a b c'
>>> "-".join({"x", "y", "z"})
'x-y-z'
>>> ", ".join(("1", "2", "3"))
'1, 2, 3'

.strip(), .lstrip() ja .rstrip() eemaldavad vaikimisi sõne otstest tühikuid, saab määrata ka muu sümboli.

>>> "           lots of space     ".rstrip()
'           lots of space'
>>> "           lots of space     ".lstrip()
'lots of space     '
>>> "           lots of space     ".strip()
'lots of space'
>>> "ttu.ee".rstrip(".e")
'ttu'
>>> "www.ttu.ee".strip(".we")
'ttu'

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: %

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'

Paremale joondamine

>>> "%20s" % "hello"
'               hello'

Vasakule joondamine

>>> "%-20s" % "hello"
'hello               '

Sõne kärpimine

>>> "%.7s" % "longstring"
'longstr'

Laiuse määramine

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

Nullidega täitmine ja täpsuse määramine

>>> "%07.3f" % 3.141592
'003.142'

a quick reference

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