Python Vadovėlis/Daugiau apie tekstines eilutes

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

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")

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 rėk() rodo, kad ciklas for gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija vidurys() rodo, kad su tekstine reikšme galima naudoti sąrašo funkciją len(), 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:

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"))

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ą ord() (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ą chr(), 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ė if 'a' <= simbolis <= 'z': patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės: Pirmiausia eilutė lokacija= ord(simbolis) - ord('a') nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t. Tada nauja reikšmė randama su kodo eilute naujas_ascii = lokacija + ord ('A'). 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 tekstoEilutė.upper(), 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 str() konvertuoja skaičių į tekstinę reikšmę (skaičiai suprantami, kaip simblių seka), o funkcija int() konvertuoja tekstinę reikšmę į sveikąjį skaičių. Funkcija float() konvertuoja tekstinę reikšmę arba skaičių į dešimtainį skaičių (skaičių su kableliu). Grįžtant prie funkcijos str() – 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 int() konvertuoja tekstinę reikšmę (ar dešimtainė skaičių) į sveikąjį skaičių. Panaši funkcija float konvertuoja skaičių ar tekstinę reikšmę į dešimtainį skaičių. Taip pat Python'o programavimo kalba turi funkciją type(), kuri grąžina kintamojo reikšmės tipą. Pavyzdžiui:

v = '123'
print(type(v))
# <class 'str'>

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

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

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

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

>>> "Č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 split() 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 split() 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'

Tekstinės (ir sąrašo) reikšmės pjaustymas (Slicing strings(and lists))

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje su sąrašais, kai laužtiniuose skliaustuose [] buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: tekstas[pradžios_indeksas:pabaigos_indeksas] (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

		0		1		2		...		-2		-1
		↓		↓		↓		↓		↓		↓		↓
tekstas =	"		S		T		R		I		N		G		"
		↑												↑
		[:												:]

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

tekstas[1:4]	→	"TRI"
tekstas[:5]	→	"STRIN"
tekstas[:-1]	→	"STRIN"
tekstas[-4:]	→	"RING"
tekstas[2]	→	"R"
tekstas[:]	→	"STRING"
tekstas[::-1]	→	"GNIRTS"

tekstas[1:4] duoda visas tekstas reikšmes tarp 1 ir 4, "TRI". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: tekstas[:5] atspausdina"STRIN". Taip pat, tiek su pradžios_indeksas, tiek su pabaigos_indeksas galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: tekstas[:-1] duoda tą patį rezultatą kaip tekstas[:5], 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: tekstas[2] duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "R". Speciali pjaustymo operacija tekstas[:] 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“: tekstas[::-1] yra tekstas nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "STRING" atvirkščiai yra "GNIRTS" (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.

Pavyzdžiai

# Š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"))

Rezultatas:

2
23445
-23445
14234
12345
-3512

Pratimai

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

Sprendimas
ž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")