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 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 [] 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.
Papasakojau tau apie pjaustymą, dabar laikas sužinoti, kaip sujungti sąrašą į vieną tekstinę eilutę. join() 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:
žodžiai = ["Sujungtas", "sakinys"] sakinys = " ".join(žodžiai) print(sakinys) # "Sujungtas sakinys"
žodžiai = ["Sujungtas", "sakinys"] sakinys = ",".join(žodžiai) print(sakinys) # "Sujungtas,sakinys"
Daugiau naudingų tekstinės eilutės funkcijų
Čia yra keletas kitų dažniausiai naudojamų tekstinės eilutės metodų Python kalboje:
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
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ų: strip() 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:
tekstas = " Sveikas, Pasauli! " švarus_tekstas = tekstas.strip() print(švarus_tekstas) # "Sveikas, Pasauli!"
tekstas = "$$$Sveikas, Pasauli!$$$"
švarus_tekstas = tekstas.strip("$")
print(švarus_tekstas) # "Sveikas, Pasauli!"
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ą:
#Š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")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ą isdecimal() . Ši funkcija gražina ar teksto eilutę galime paversti į sveikąjį skaičių.
Aukšiau pateiktą, kodą galime patobulinti šitaip:
#Š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ų")
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ų Siekiant tobulumo.
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
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ė.
| Sprendimas | |
|---|---|
į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ė)])
| |
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".
| Sprendimas | |
|---|---|
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)
| |
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')
| 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")
| |