Kintamieji

Kintamajieji (variables)

Kalbant abstrakčiai kiekvieną „Python“ elementą galima apibūdinti terminu objektas, o manipuliuoti objektais galime naudojant simbolinius pavadinimus, kuriuos ir vadiname kintamaisias. Kintamieji - tai vietos, kuriose kompiuterio programa įsirašo viską, ką reikia prisiminti, o kuriant sudėtingesnį kodą, programai reikia duomenų, kurie gali pasikeisti ją vykdant.

Kintamųjų kūrimas

Kadangi Python programavimo kalba neturi specialios komandos kintamiesiems deklaruoti, tai juos sukuriame tada, kai priskiriame, kokią nors reikšmę. Pavyzdžiui:

vardas = 'Rokas'
amžius = 25

Svarbu atkreipti dėmesį, kad kuriant kintamuosius yra svarbus jų užrašymas (t.y. didžiosios ir mažosios raidės, negali būti jokių tarpų), todėl užrašius vardas ir Vardas turėsime du skirtingus kintamuosius.

vardas = 'Rokas'
Vardas = 'Sandra'

Taip pat, kai kuriame kintamuosius, mes nedeklaruojame jų tipo ir netgi, jeigu norime galime kintamųjų tipus keisti. Pavyzdžiui:

amžius = str(25) # programa šį kintamąjį atspausdins kaip tekstą: '25'
amžius = int(25) # šį kaip skaičių: 25
amžius = float(25) #o šis kintamasis bus programos bus suprastas kaip float(skaičius su reikšme po kablelio): 25.0

Kintamųjų pavadinimas

Kuriant kintamuosius labai svarbu suprasti, kad juos užrašydami turėtume kurti, kuo tikslesnius pavadinimus - juk prirašius daugybę kodo eilučių ar sugrįžus prie kodo po kurio laiko reikia suprasti, ką reiškia kintamasis. Pavyzdžiui:

#reikėtų vengti tokio užrašymo
x = 'Rokas'
y = 'Rokaitis'
z = 25
#geriau kuriant kintamuosius, juos užrašyti tiksliai pagal jų reikšmę
vardas = 'Rokas'
pavardė = 'Rokaitis'
amžius = 25

Kintamuosius susidedančius iš kelių žodžių, dėl bendros tvarkos, atsižvelgiant į Python programavimo kalbos stiliaus gaires, galima užrašyti naudojantis CamelCase (kupranugario būdu) arba snake_case (gyvetėlės būdu). Nors įprastai, kintamųjų kūrimui naudojamas snake_case, pavyzdžiui:

vardas_pavardė = 'Rokas Rokaitis'
šiaurės_koordinatės = 'N'
mokymosi_laikas = '4 valandos'

Galimi kintamųjų pavadinimai:

manovardas = "Rokas"
mano_vardas = "Rokas"
_mano_vardas = "Rokas"
manoVardas = "Rokas"
MANOVARDAS = "Rokas"
manovardas2 = "Rokas"

Dažnai pasitaikančios kintamųjų užrašymo klaidos:

2manovardas = "Rokas" # kintamųjų pavadinimas negali prasidėti skaičiumu
mano-vardas = "Rokas" # kintamųjų pavadinimo negalima skirti brūkšnio simboliu
mano vardas = "Rokas" # kintamųjų pavadinime negali būti tarpo

Kelių reikšmių priskyrimas

Programuojant naudinga žinoti, kaip priskirti kelias reikšmes tam pačiam kintamajam arba kaip lengvai priskirti kelias reikšmes keliems kintamiesiems. Paprastai reikšmė priskiriama naudojant lygybės = ženklą, o skirtingas reikšmes atskiriant kableliu ,.

Kelios reikšmės keliems kintamiesiems

Skirtingas reikšmes keliems kintamajam priskiriam jas atskirdami kableliais ,, pavyzdžiui:

pirmas_mokinys, antras_mokinys = "Rokas", "Sandra"

rašyk(pirmas_mokinys)
# Rokas

rašyk(antras_mokinys)
#Sandra

Taip pat galima priskirti ir daugiau reikšmių, kurios gali būti ir skirtingo tipo:

pirma_reikšmė, antra_reikšmė, trečia_reikšmė = 0.54, 10, 'Angis'

rašyk(pirma_reikšmė)
# 0.54

rašyk(antra_reikšmė)
# 10

rašyk(trečia_reikšmė)
# Angis

• Sudėtingesnė informacija, kurią dabar gali praleisti, bet bus naudinga, kuriant sudėtingesnes programas.

Jeigu yra vienas kintamasis ir kelios reikšmės, tai bus sukuriamas tuple:

metai = 2001, 2017

rašyk(metai)
rašyk(type(metai))
# (2001, 2017)
# <class 'tuple'>

Jeigu kintamųjų ir reikšmių skaičius abiejose pusėse nesutampa, tai gausime klaidą VallueError, tačiau papildomas reikšmes kintamąjam galime priskirti naudodami žvaigždutės simbolį*. Pavyzdžiui:

# kilometrai, metrai = 100, 200, 300
# ValueError: too many values to unpack (expected 2) (ValueError: perdaug reikšmių išpakavimui (tikėtasi 2)

# kilometrai, metrai, centimetrai = 10, 250
# ValueError: not enough values to unpack (expected 3, got 2) (ValueError: nepakankamai reikšmių išpakavimui (tikėtasi 3, gauta 2)

kilometrai, *metrai = 10, 250, 30

rašyk(a)
rašyk(type(a))
# 10
# <class 'int'>

rašyk(b)
rašyk(type(b))
# [250, 30]
# <class 'list'>

*kilometrai, metrai = 10, 250, 30

rašyk(a)
rašyk(type(a))
# [10, 250]
# <class 'list'>

rašyk(b)
rašyk(type(b))
# 30
# <class 'int'>

Viena reikšmė keliems kintamiesiems

Priskirti tą pačią reikšmę keliems kintamiesiems galima naudojantis lygybės ženklu =. Pavyzdžiui:

honda = audi = ford = "Automobilis"

Taip pat verta įsidėmėti, kad kintamųjų reikšmes Python programavimo kalboje lengva perrašyti:

honda = audi = ford = "Automobilis"

rašyk(honda)
# Automobilis

rašyk(audi)
# Automobilis

rašyk(ford)
# Automobilis

#bet jeigu hondai priskirsime kitą reikšmę, tai programa spausdins paskutinę perskaitytą reikšmę

honda = "Motociklas"

rašyk(honda)
# Motociklas

rašyk(audi)
# Automobilis

rašyk(ford)
# Automobilis

Reikšmių išpakavimas (collection unpacking)

Jeigu yra išsaugotos kelios reikšmės pavyzdžiui sąraše (list), tuple, žodyne (dictionary) ar pnš., tai Python programavimo kalba leidžia išpakuoti reikšmes į kintamuosius. Pavyzdžiui:

medžiai = ["ąžuolas", "liepa", "uosis"]
pirmas_medis, antras_medis, trečias_medis = medžiai
rašyk(pirmas_medis) # ąžuolas
rašyk(antras_medis) # liepa
rašyk(trečias_medis) # uosis

Kintamųjų išvestis (output variables)

Tam, kad mes pamatytume atspausdintus kintamuosius naudojame funkciją print() arba Angyje rašyk().

Jeigu norime sujungti turimą tekstą su kintamuoju, tai naudojame pliuso + ženklą. Pavyzdžiui:

parduotuvės_pavadinimas = "Eglutė"
rašyk("Artimiausia parduotuvė yra " + "Eglutė" + ".")
# Artimiausia parduotuvė yra Eglutė.

Kaip tai panaudojama programoje, gali pamatyti šiame angies vartotojo kurtame kartuvių žaidime.

pralaimejai = žaidimas.Tekstas('Pralaimejai, žodis buvo "' + žodis + '"')

Taip pat, pasinaudojant + ženklu galime sujungti kelias skirtingas tekstines kintamųjų reikšmes:

vardas = "Mantas"
informacija = " šiandien švenčia savo gimtadienį."

sakinys = vardas + informacija
rašyk(sakinys)
# Mantas šiandien švenčia savo gimtadienį.

Taip pat, jeigu naudojame skaičius juos galime sujungti su + ženklu.

gimimo_metai = 2000
amžius = 21
dabartiniai_metai = gimimo_metai + amžius
rašyk(dabartiniai_metai)
# 2021

Tačiau reikia atkreipti dėmesį, kad negalime sujungti tekstinės eilutės su skaičiais. Pabandyk ir įsitikink:

amžius = 18
vardas = "Aurimas"
rašyk(vardas + amžius)
#TypeError: unsupported operand type(s) for +: 'int' and 'str' (Rašybos klaida. Netinkamas kintamųjų formatas +(pliusui):'int'+ 'str'

Dinaminis rašymas (Dynamic Typing)

Python programavimo kalba leidžia keisti kintamuosius ir jų tipą tada, kada norime. Pavyzdžiui:

metai = True
rašyk(metai) # True

metai = 2021
rašyk(metai) # 2021

metai = None
rašyk(metai) # None

metai = 1.5
rašyk(metai) # 1.5

metai = "Du tūkstančiai pirmi"
rašyk(metai) # Du tūkstančiai pirmi

Kaip matai, tą patį kintamąjį programoje galime perrašyti daugybę kartų ir visiškai nesvarbu, koks duomenų tipas. Na, o pavyzdžiui, statinio rašymo kalboje C++ taip rašyti negalėtume.

int skaičius = 5;
skaičius = "penki"; // !Error

Daugiau pasiskaityti apie galimus duomenų tipus gali duomenų tipų puslapyje.

Globalūs ir lokalūs kintamieji (global and local variables)

Python programavimo kalboje kiekvienas kintamasis panaudotas už funkcijos ribų yra vadinamas globaliu kintamuoju. Tai reiškia, kad globalus kintamasis yra prieinamas tiek funkcijos viduje, tiek išorėje. Pavyzdžiui:

globalus_kintamasis = "šypsokis!"

def bandymas():
    rašyk("globalus kintamasis funkcijos viduje: " + globalus_kintamasis)


bandymas() # globalus kintamasis funkcijos viduje: šypsokis!
rašyk("globalus kintamasis užfunkcijos ribų: " + globalus_kintamasis) #globalus kintamasis už funkcijos ribų: šypsokis!

Kaip matai, mes sukūrėme globalų kintamąjį globalus_kintamasis ir sukūrėme funkciją bandymas(), kad atspausdintų globalų kintamąjį globalus_kintamasis. Tada iškvietėme funkciją bandymas(), kuri atspausdino kintamojo reikšmę.

O kas nutiktų, jeigu sukurtum kitamąjį tokiu pat pavadinimu, bet funkcijos viduje arba kitaip tariant lokalų kintamąjį? Iš principo lokalus kintamasis būtų prieinamas tik funkcijos viduje, o visa, kas yra už funkcijos ribų ir toliau naudotų globalaus kintamojo reikšmę.

medis = "uosis"
def medkirtys():
    medis = "beržas"
    rašyk("Medkirčio mėgstamiausias medis yra " + medis)

medkirtys() # Medkirčio mėgstamiausias medis yra beržas

rašyk("Genio mėgstamiausias medis yra " + medis) # Genio mėgstamiausias medis yra uosis

Globalus raktažodis (global Keyword)

Trumpai:

• kai sukuriame kintamąjį funkcijos viduje jis automatiškai yra lokalus
• kai sukuriame kintamąjį už funkcijos ribų jis automatikškai yra globalus, todėl nereikia naudoti raktažodžio global
• kai funkcijos viduje prieš kintamąjį panaudojame žodį global, tai kintamasis tampa globaliu ir prieinamu visam kode

Globalus raktažodis Python programavimo kalboje leidžia modifikuoti kintamąjį už jo ribų. Todėl, prieš lokalų kintamąjį esantį funkcijos viduje, parašę žodį global jį paverčiame globaliu kintamuoju ir prieinamu už funkcijos ribų:

def medkirtys():
    global medis
    medis = "uosis"
    rašyk(medis)

madkirtys() # uosis
rašyk("Mano mėgstamiausias medis yra " + medis) # Mano mėgstamiausias medis uosis

Kaip matote, lokalų kintamąjį medis mes panaudojome ir už funkcijos ribų naudodami funkciją rašyk(). Taip pat, sukūrę globalų kintamąjį funkcijos viduje, galime pakeisti globalaus kintamjo reikšmę esančią už funkcijos ribų:

medis = "uosis"
def medkirtys():
    global medis
    medis = "beržas"
    rašyk("Medkirčio mėgstamiausias medis yra " + medis)

medkirtys() # Medkirčio mėgstamiausias medis yra beržas

rašyk("Genio mėgstamiausias medis yra " + medis) # Genio mėgstamiausias medis yra beržas