Peržiūrėti šaltinį Vadovėlis/Daugiau apie tekstines eilutes

{{navigation |previous=Paieška ir Rikiavimas|next=Daugiau apie funkcijas}}

Šiame skyriuje pamatysi, kiek šaunių dalykų galime padaryti su tekstine reikšme:

<syntaxhighlight lang="python">
def rėk(tekstinė_reikšmė):
    for raidė in tekstinė_reikšmė:
        print("Duok man " + raidė)
        print("'" + raidė + "'")

rėk("Ačiū")

def vidurys(tekstas):
    print("Raidė esanti viduryje yra:", tekstas[len(tekstas) // 2])

vidurys("abcdefg")
vidurys("The Python Programming Language")
vidurys("Atlanta")
</syntaxhighlight>

Rezultatas:

 Duok man A
 'A'
 Duok man č
 'č'
 Duok man i
 'i'
 Duok man ū
 'ū'
 Raidė esanti viduryje yra: d
 Raidė esanti viduryje yra: r
 Raidė esanti viduryje yra: a

Šios dvi programos rodo, kad tekstinė reikšmė (string) yra keliais aspektais panaši į sąrašą (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad su tekstine reikšme galima naudoti sąrašo funkciją <code>len()</code>, taip pat sąrašo indeksavimu ir pjaustymu. Taigi, dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

Kita šio skyriaus funkcija parodo tam tikras tekstinės reikšmės ypatybes:
<syntaxhighlight lang="python">
def pavertimas_didžiosiomis_raidėmis(tekstas):
    ## Ši funkcija, tekstinę reikšmę užrašo didžiosiomis raidėmis
    didžiosios_raidės = ""
    for raidė in tekstas:
        if 'a' <= raidė <= 'z':
            lokacija = ord(raidė) - ord('a')
            naujas_ascii = lokacija + ord('A')
            raidė= chr(naujas_ascii)
        didžiosios_raidės = didžiosios_raidės + raidė
    return didžiosios_raidės

print(pavertimas_didžiosiomis_raidėmis("Įrašytas tekstas"))
</syntaxhighlight>

Rezultatas:

 ĮRAŠYTAS TEKSTAS

Tai veikia, nes kompiuteris tekstinės reikšmės simbolius šifruoja skaičiais nuo 0 iki 1 114 111. Visos šios tekstinės reikšmės turi savo unikalias unikodo reikšmes. Pavyzdžiui, simboliui „A“ yra priskirtas skaičius 65, simbolis „B“ kompiuterio suprantamas kaip 66, o simbolis א yra 1488. Visi simboliai yra tarsi surikiuoti ir turi savo eilės numerį. Python'o programavimo kalba turi funkciją, vadinamą <code>ord()</code> (trumpinys angliško žodžio ordinal, kuris reiškia iš eilės), kuri grąžina simbolio skaičių (eilės numerį_. Taip pat Python'o programavimo kalba turi ir atvirkščią funkciją, vadinamą <code>chr()</code>, kuri skaičių paverčia simboliu. Supratus, kaip veikia šios funkcijos aukščiau užrašyta programa turėtų atrodyti logiška.

Programos pirmoji eilutė <code>if 'a' <= simbolis <= 'z':</code> patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės:
Pirmiausia eilutė <code>lokacija= ord(simbolis) - ord('a')</code> nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t. 
Tada nauja reikšmė randama su kodo eilute <code>naujas_ascii = lokacija + ord ('A')</code>. 
Tada ši reikšmė paverčiama atgal į simbolį, kuris dabar yra didžioji raidė. 

Žinoma, tai tik programos pavyzdys, tačiau daug paprasčiau tai padaryti naudojantis funkcija <code>tekstoEilutė.upper()</code>, kuri veikia su visomis kalbomis.

O dabar pabandykime pasižiūrėti į šį pavyzdį:

 >>> '''# Skaičius į tekstinę reikšmę'''
 >>> '''2'''
 2
 >>> '''str(2)'''
 '2'
 >>> '''-123'''
 -123
 >>> '''str(-123)'''
 '-123'
 >>> '''# Tekstinė reikšmė į skaičių'''
 >>> '''"23"'''
 '23'
 >>> '''int("23")'''
 23
 >>> '''"23" * 2'''
 '2323'
 >>> '''int("23") * 2'''
 46
 >>> '''# Skaičius po kablelio į tekstinę reikšmę'''
 >>> '''1.23'''
 1.23
 >>> '''str(1.23)'''
 '1.23'
 >>> '''# Skaičius po kablelio į skaičių'''
 >>> '''1.23'''
 1.23
 >>> '''int(1.23)'''
 1
 >>> '''int(-1.23)'''
 -1
 >>> '''# Tekstinė reikšmė į skaičių po kablelio'''
 >>> '''float("1.23")'''
 1.23
 >>> '''"1.23"''' 
 '1.23'
 >>> '''float("123")'''
 123.0

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę (skaičiai suprantami, kaip simblių seka), o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į sveikąjį skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į dešimtainį skaičių (skaičių su kableliu). Grįžtant prie funkcijos <code>str()</code> – ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

 >>> '''str(1)'''
 '1'
 >>> '''str(234.14)'''
 '234.14'
 >>> '''str([4, 42, 10])'''
 '[4, 42, 10]'

Funkcija <code>int()</code> konvertuoja tekstinę reikšmę (ar dešimtainė skaičių) į sveikąjį skaičių. Panaši funkcija <code>float</code> konvertuoja skaičių ar tekstinę reikšmę į dešimtainį skaičių. Taip pat Python'o programavimo kalba turi funkciją <code>type()</code>, kuri grąžina kintamojo reikšmės tipą. Pavyzdžiui:

<syntaxhighlight lang="python">
v = '123'
print(type(v))
# <class 'str'>

v = 645.123
print(type(v))
# <class 'float'>

v = [1, 2, 3]
print(type(v))
# <class 'list'>
</syntaxhighlight>

Naudojant funkciją <code>type()</code> pasitikrink, ar grąžinamas toks reikšmės tipas, kurio tikėjaisi.

Taip pat naudingas ir dažnai paprastose užduotyse naudojama funkcija <code>split()</code>:

 >>> '''"Čia yra tik žodžių kratinys".split()'''
 ['Čia', 'yra', 'tik', 'žodžių', 'kratinys']
 >>> '''tekstas= "Pirma partija, antra partija, trečia, ketvirta"'''
 >>> '''tekstas.split(",")'''
 ['Pirma partija', ' antra partija', ' trečia', ' ketvirta']

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Kai funkcijai nenurodytas argmentas – skyriklis, pagal ką suskirstyti į skirtingus sąrašo elementus, funkcija skirsto pagal tarpus. Antrame pavyzdyje skyriklis yra kablelis.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

 >>> '''sąrašas= tekstas.split(",")'''
 >>> '''len(sąrašas)'''
 4
 >>> '''sąrašas[-1]'''
 ' ketvirta'
 >>> '''sąrašas = tekstas.split(",", 2)'''
 >>> '''len(sąrašas)'''
 3
 >>> '''sąrašas[-1]'''
 ' trečia, ketvirta'

<!-- TODO add more on strings -->
=== Tekstinės (ir sąrašo) reikšmės pjaustymas ir sujungimas ===

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje su sąrašais, kai laužtiniuose skliaustuose <code>[]</code> buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: <code>tekstas[pradžios_indeksas:pabaigos_indeksas]</code> (retais atvejais galime pridėti dar ir trečią argumentą, kaip apačioje esančiame pavyzdyje).

Kad nesusipainiotum įrašydamas indekso skaičius, įsivaizduok, kad žirklėmis karpai tekstą, o programai nurodai, kurioje vietoje kirpti. Štai vienas pavyzdys, kaip tai viekia – geltonai pažymėtos kirpimo vietos, o raudonai ir mėlynai indekso numeris

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | -2
| style="width:2ex" |
| style="width:2ex;color:blue" | -1
| style="width:2ex" |
| style="width:2ex" |
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
|-
| tekstas = 
|"
| style="background:#FFFF88" |
!S 
| style="background:#FFFF88" |
!T
| style="background:#FFFF88" |
!R
| style="background:#FFFF88" |
!I
| style="background:#FFFF88" |
!N
| style="background:#FFFF88" |
!G
| style="background:#FFFF88" |
|"
|-
|
|
| style="background:#FFFF88" |&uarr;
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |&uarr;
|
|-
|
|
|[:
|
|
|
|
|
|
|
|
|
|
|
|:]
|
|}
</tt>

Įsidėmėk, kad raudonai pažymėti indeksai skaičiuojami nuo pradžios, o mėlyni atvirkščiai nuo kito galo t.y. teksto pabaigos. Taip pat ar pastebėjai, kad skaičiuojant nuo galo nėra -0 reikšmės? Taip yra todėl, kad 0 visada priskiriamas tik reikšmės pradžiai:

<tt>
{|
|-
|tekstas[1:4] || style="width:3em;text-align:center" | &rarr; || "TRI"
|-
|tekstas[:5] || style="width:3em;text-align:center" | &rarr; || "STRIN"
|-
|tekstas[:-1] || style="width:3em;text-align:center" | &rarr; || "STRIN"
|-
|tekstas[-4:] || style="width:3em;text-align:center" | &rarr; || "RING"
|-
|tekstas[2] || style="width:3em;text-align:center" | &rarr; || "R"
|-
|tekstas[:] || style="width:3em;text-align:center" | &rarr; || "STRING"
|-
|tekstas[::-1] || style="width:3em;text-align:center" | &rarr; || "GNIRTS"
|}
</tt>

<tt>tekstas[1:4]</tt> duoda visas <tt>tekstas</tt> reikšmes tarp 1 ir 4, "<tt>TRI</tt>". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: <tt>tekstas[:5]</tt> atspausdina"<tt>STRIN</tt>". Taip pat, tiek su <tt>pradžios_indeksas</tt>, tiek su <tt>pabaigos_indeksas</tt> galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: <tt>tekstas[:-1]</tt> duoda tą patį rezultatą kaip <tt>tekstas[:5]</tt>, todėl, kad indekas -1 šiame žodyje yra toje pačioje vietoje kaip indeksas 5. Jeigu nenaudojame argumento kartu su dvitaškiu, tai skaičius traktuojamas kitaip, pavyzdžiui: <tt>tekstas[2]</tt> duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "<tt>R</tt>". Speciali pjaustymo operacija <tt>tekstas[:]</tt> reiškia nuo pradžios iki pabaigos ir duodą visos tekstinės reikšmės ar sąrašo (list) kopiją. 

Na ir galiausiai, pjaustymo operacija gali turėti ir trečią argumentą, kuris suprantamas, kaip „žingsnio dydis“: <tt>tekstas[::-1]</tt> yra <tt>tekstas</tt> nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "<tt>STRING</tt>" atvirkščiai yra "<tt>GNIRTS</tt>" (jeigu nesupratai, tai pabandyk prasitestuoti įrašydamas kaip žingsnio ilgį skaičių 2).

Visos šios pjaustymo operacijos veikia ir su sąrašais (lists). Šiuo atveju tekstinę reikšmę galime suprasti, kaip sąrašą, kai visi sąrašo elementai yra atskiros raidės. Iš šio skyriaus atsimink pagrindinį principą - į viską žiūrėk taip lyg karpytum, tai padės nesusipainioti įrašant indeksus.

Papasakojau tau apie pjaustymą, dabar laikas sužinoti, kaip sujungti sąrašą į vieną tekstinę eilutę. <code>join()</code> yra Python kalbos integruota funkcija, kuri naudojama sujungti kelis teksto fragmentus į vieną eilutę. Ji naudojama su teksto eilute kaip metodo argumentu ir jungia kiekvieną elementą iš sąrašo arba kolekcijos, naudojant tą eilutę kaip jungiamąjį simbolį. Pavyzdžiui:

<syntaxhighlight lang="python">
žodžiai = ["Sujungtas", "sakinys"]
sakinys = " ".join(žodžiai)
print(sakinys) # "Sujungtas sakinys"
</syntaxhighlight>

<syntaxhighlight lang="python">
žodžiai = ["Sujungtas", "sakinys"]
sakinys = ",".join(žodžiai)
print(sakinys) # "Sujungtas,sakinys"
</syntaxhighlight>

=== Daugiau naudingų tekstinės eilutės funkcijų  ===

Čia yra keletas kitų dažniausiai naudojamų tekstinės eilutės metodų Python kalboje:

<syntaxhighlight lang="python">

tekstas = 'Čia yra tekstinė eilutė. '

# `upper` keičia visus simbolius eilutėje į didžiąsias raides.
tekstas.upper() # 'ČIA YRA TEKSTINĖ EILUTĖ.'

# `lower` keičia visus simbolius eilutėje į mažąsias raides.
tekstas.lower() # 'čia yra tekstinė eilutė.'

# `strip` pašalina tarpus iš eilutės pradžios ir pabaigos.
tekstas.strip() # 'Čia yra tekstinė eilutė.'

# `replace` keičia visus senos eilutės pasikartojimus nauja eilute.
senas = 'tekstinė'
naujas = 'pakeista'
tekstas.replace(senas, naujas) # 'Čia yra pakeista eilutė.'

# `find` grąžina pirmo pasikartojimo indeksą, arba -1 jei nerasta.
ieškomas_žodis = 'yra'
tekstas.find(ieškomas_žodis) # 4

# `startswith` grąžina 'true' jei eilutė prasideda su nurodytu priešdėliu.
priešdėlis = 'Čia'
tekstas.startswith(priešdėlis) # True

# `endswith` grąžina 'true' jei eilutė baigiasi su nurodyta priesaga.
priesaga = 'eilutė.'
tekstas.endswith(priesaga) # True

</syntaxhighlight>

Svarbu žinoti, kad šie metodai grąžina naują eilutę ir nekeičia originalios eilutės.

Pažiūrėkime iš arčiau į vieną iš šių metodų: <code>strip()</code> yra Python kalbos integruota funkcija, kuri naudojama pašalinti tarpus iš teksto eilutės pradžios ir/arba pabaigos. Jei nori pašalinti kitus simbolius, tau reikia nurodyti juos kaip papildomus argumentus funkcijai. Pavyzdžiui:

<syntaxhighlight lang="python">
tekstas = "   Sveikas, Pasauli!   "
švarus_tekstas = tekstas.strip()
print(švarus_tekstas) # "Sveikas, Pasauli!"
</syntaxhighlight>

<syntaxhighlight lang="python">
tekstas = "$$$Sveikas, Pasauli!$$$"
švarus_tekstas = tekstas.strip("$")
print(švarus_tekstas) # "Sveikas, Pasauli!"
</syntaxhighlight>

Taigi strip() funkcija leidžia pašalinti ne tik tarpus, bet ir kitus simbolius iš teksto eilutės pradžios ir/arba pabaigos.

=== Ar įvestas sveikasis skaičius? ===
Panagrinėkime paprastą kodą:
<syntaxhighlight lang="python">
#Ši programa patikrina ar įvestas sveikasis sakičius yra lyginis
skaičius = int(input("Sveikasis skaičius: "))
if (skaičius % 2) == 0:
    print("Lyginis")
else:
    print("Nelyginis")
</syntaxhighlight>Kas atsitiktų, jeigu įvestume ne skaičių, o pavyzdžiui žodį "pitonas"? Jei pabandytumn įvykdyti progamą, pamatytum, jog tokiu atveju įvyktų klaida. Kaip patikrinti ar įvestas tekstas yra skaičius? Tam galime panaudoti funkciją <code>isdecimal()</code> . Ši funkcija gražina ar teksto eilutę galime paversti į sveikąjį skaičių.
Aukšiau pateiktą, kodą galime patobulinti šitaip:

<syntaxhighlight lang="python">
#Ši programa patikrina ar įvestas sakičius yra lyginis
įvestas_skaičius = input("Sveikasis skaičius: ")
if įvestas_skaičius.isdecimal():
    skaičius = int(įvestas_skaičius)
    if (skaičius % 2) == 0:
        print("Lyginis")
    else:
        print("Nelyginis")
else:
    print("Įvedei ne sveikąjį skaičių")
</syntaxhighlight>

Išsiaiškinome kaip patikrinti ar teskto eilutę galime konvertuotį į sveikjį skaičių. O ką daryti jei norime patikrinit ar galime konvertutuoti į realųjį skaičių. Deja tokios paprastos funkcijos nėra, tad reikia naudoti kitokius metodus. Kaip tai padaryti pamatyri perskaitęs skyrių [[Vadovėlis/Siekiant tobulumo|Siekiant tobulumo]]. 

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa reikalauja dešimtainių skaičių supratimo.
def į_tekstą(į_skaičių):
    """Konvertuoja skaičių į tekstą"""
    tekstas = ""
    prefiksas = ""
    if į_skaičių < 0:
        prefiksas = "-"
        į_skaičių = -į_skaičių
    while į_skaičių // 10 != 0:
        tekstas = str(į_skaičių % 10) + tekstas
        į_skaičių= į_skaičių// 10
    tekstas = str(į_skaičių % 10) + tekstas
    return prefiksas + tekstas

def į_skaičių(į_tekstą):
    """Konvertuoja tekstą į skaičių"""
    skaičius = 0
    if į_tekstą[0] == "-":
        daugiklis = -1
        į_tekstą = į_tekstą[1:]
    else:
        daugiklis = 1
    for c in į_tekstą:
        skaičius = skaičius* 10 + int(c)
    return skaičius * daugiklis

print(į_tekstą(2))
print(į_tekstą(23445))
print(į_tekstą(-23445))
print(į_skaičių("14234"))
print(į_skaičių("12345"))
print(į_skaičių("-3512"))
</syntaxhighlight>

Rezultatas:

 2
 23445
 -23445
 14234
 12345
 -3512

=== Pratimai ===
1. Parašyk programą, kuri sukonstruotų žodį iš pirmų 2 ir paskutinių 2 įvestos tekstinės eilutės simbolių. Pvz., įvedus “Moku programuoti pitonu”, programa turėtų išvesti “Monu”. Jei įvesta eilutė yra trumpesnė, nei du simboliai, turėtų būti išvedama tuščia eilutė.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas &nbsp;
|-
|
<syntaxhighlight lang="python">
įvesta_eilutė = input("Įvesk tekstinę eilutę: ")

if len(įvesta_eilutė) < 2:
    print("")
else:
    print(įvesta_eilutė[:2] + įvesta_eilutė[len(įvesta_eilutė)-2:len(įvesta_eilutė)])
</syntaxhighlight>
|-
|}


2. Parašyk programą, kuri prašytų įvesti du žodžius ir išvestų tuos žodžius apverstus ir sujungtus tarpu. Pavyzdžiui, jei vartotojas įveda "Labas" ir "rytas", programa turėtų išvesti "sabaL satyr".

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas &nbsp;
|-
|
<syntaxhighlight lang="python">
pirmas = input("Įvesk pirmą žodį: ")
antras = input("Įvesk antrą žodį: ")

pirmas_apverstas = pirmas[::-1]
antras_apverstas = antras[::-1]

sujungta = " ".join([pirmas_apverstas, antras_apverstas])

print(sujungta)
</syntaxhighlight>
|-
|}


3. Parašyk programą, kuri prašo vartotojo įvesti žodį arba sakinį. Tada programa turi pasakyti, ar įvestas žodis/sakinys yra palindromas (žodis, eilėraštis arba frazė, skaitomi iš kairės į dešinę ir iš dešinės į kairę, išlaikantys tą pačią prasmę. Pvz., lietuvių k. žodis savas, sakinys 'Abu gaišo po šia guba')

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas &nbsp;
|-
| 
<syntaxhighlight lang="python">

žodis = input("Iveskite žodį")

def yra_palindromas(ž):
    ž_nuo_galo = ""
    for i in ž:
        ž_nuo_galo = i + ž_nuo_galo
    return ž_nuo_galo == ž

ats = yra_palindromas(žodis)

if ats:
    print("Įvestas žodis yra palindromas")
else:
    print("Įvestas žodis nėra palindromas")

</syntaxhighlight>
|-
|}

{{navigation |previous=Paieška ir Rikiavimas|next=Daugiau apie funkcijas}}
[[Category:Python Vadovėlis]]