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. Mitme realine sõne tuleb piiritleda kolmekordsete jutumärkidega.

Pythonis on sõne tüübi tähistuseks str.

Loomine:

str1 = "hello"
str2 = 'ABC'
str3 = """
 _____         _    _
|  __ \       | |  | |
| |__) |_   _ | |_ | |__    ___   _ ___
|  ___/| | | || __|| '_ \  / _ \ | '_' |
| |    | |_| || |_ | | | || (_) || | | |
|_|     \__, | \__||_| |_| \___/ |_| |_|
         __/ |
        |___/
"""

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'
str2 = "Bell UH-1 'Huey' Iroquois"
str3 = "Bell UH-1 \"Huey\" Iroquois"
str4 = "To understand what recursion is,\nyou must first understand recursion."
str5 = "C:\\dev\\string.py"
print(str4)  # -> To understand what recursion is,
#                 you must first understand recursion.
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 = "Supermarine Seafire"

# single character with slice notation
print(str1[2:3])  # -> p

# notation for getting a single character
print(str1[2])  # -> p

# use negative numbers to get characters from the end
print(str[-1])  # -> e

# range of elements between index 0 and index 2, element at index 2 is excluded
print(str1[0:2])  # -> Su

# [start] can be omitted
print(str1[:2])  # -> Su

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

# [stop] can be omitted
print(str1[2:])  # -> permarine Seafire

# last three characters
print(str1[-3:])  # -> ire

# slicing from start to end, easy way to make a copy
print(str1[:])  # -> Supermarine Seafire

# by choosing [step] to be -1, we get the reverse of original
print(str1[::-1])  # -> erifaeS eniramrepuS

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.

aircraft1 = "Douglas DC-3"
aircraft1 = "Hawker Hurricane"  # reassigning a new string to variable
aircraft2 = "Supermarine Spitfire"
aircraft3 = aircraft2[:11] + " Seafire"

print(aircraft1)  # -> Hawker Hurricane
print(aircraft2)  # -> Supermarine Spitfire
print(aircraft3)  # -> Supermarine Seafire

+ 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("F" in lorem)  # False
print("consectetur" in lorem)  # True
print("Amet" not in lorem)  # True

Sõne pikkust saab leida funktsiooniga len().

>>> str1 = "bacon"
>>> len(str1)
5
>>> len("abc 123")
7

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

>>> a = "30"
>>> int(a)
30
>>> type(int(a))
<class 'int'>
>>> c = "125.75"
>>> float(c)
125.75
>>> type(float(c))
<class 'float'>
>>> d = 500
>>> str(d)
'500'
>>> type(str(d))
<class 'str'>

Sõne sisseehitatud funktsioonid

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

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

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

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

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

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

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

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

>>> str2 = "bobobob"
>>> str2.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

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

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

>>> str1.find("y")
1
>>> str1.index("y")
1
>>> str1.find("z")
-1
>>> str1.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

>>> str1.isalpha()
True
>>> str3 = "abc123"
>>> str3.isalpha()
False
>>> str3.islower()
True
>>> str3.isnumber()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'isnumber'
>>> str3.isnumeric()
False
>>> str4 = "55"
>>> str4.isdecimal()
True
>>> str5 = "UPPER"
>>> str5.isupper()
True

.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.

Oht

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

>>> "{Tim} {Alice}".format(Tim="Software Architect", Alice="Graphic Designer")
'Software Architect Graphic Designer'
>>> jobs = {"Tim": "Software Architect", "Alice": "Graphic Designer"}
>>> "Jobs:{Tim}, {Alice}".format(**jobs)
'Jobs:Software Architect, Graphic Designer'

Erinevate andmestruktuuride kasutamine

>>> data = {"apple": 22, "pear": 17}
>>> "{d[apple]} {d[pear]}".format(d=data)
'22 17'
>>> languages = ["Python", "Java", "Javascript", "C#", "C++", "Swift"]
>>> "{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
>>> 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"]
>>> f"{languages[4]}, {languages[5]}"
'C++, Swift'

Saab kasutada mistahes legaalset Pythoni avaldist

>>> def foo():
...     return 25
...
>>> f"result = {foo()}"
'result = 25'

Vormingu täpsustamine avaldistega

>>> import math
>>> width = 10
>>> precision = 6
>>> f"The value of tau is {(math.pi * 2):{width}.{precision}}"
'The value of tau is    6.28319'

Nullidega täitmine

>>> n = 5
>>> f"{n:02}"
'05'
>>> a = 22
>>> f"{a:05}"
'00022'