Knyga/Loginiai reiškiniai - Versijų istorija

ArturasNik 12:34, 5 rugpjūčio 2025

2025-08-05T12:34:19Z

← Ankstesnė versija		15:34, 5 rugpjūčio 2025 versija
121 eilutė:		121 eilutė:
	Turėk omeny, jei pirmasis reiškinys yra teisingas Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys bus teisingas. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code>, jei bent vienas iš reiškinių yra teisingas, tuomet viso reiškinio galutinis rezultatas bus teisingas. Pirmoji dalis yra teisinga, todėl antroji dalis gali būti klaidinga arba teisinga, tačiau visa išraiška vis dar teisinga.		Turėk omeny, jei pirmasis reiškinys yra teisingas Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys bus teisingas. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code>, jei bent vienas iš reiškinių yra teisingas, tuomet viso reiškinio galutinis rezultatas bus teisingas. Pirmoji dalis yra teisinga, todėl antroji dalis gali būti klaidinga arba teisinga, tačiau visa išraiška vis dar teisinga.

	Aštuntoje: <code>print(8, not (a == 7 and b == 6))</code> ir devintoje: <code>print(9, not a == 7 and b == 6)</code> eilutėse yra atvaizduojamas reiškinių grupavimo pavyzdys. Reiškinius Python’e galima sugrupuoti naudojant skliaustelius. Sugrupavę reiškinius, mes priverčiame Python’ą iš pradžių įvertinti reiškinius skliaustuose ir tik tada likusias reiškinio dalis. Atkreipk dėmesį, kad skliausteliai pakeitė ~~reiškinį iš neteisingo į teisingą~~. Taip nutiko dėl to, kad operatorius <code>not</code> buvo pritaikytas reiškiniui skliausteliuose, vietoj to, kad būtų pritaikytas tik <code>a == 7</code> daliai.		Aštuntoje: <code>print(8, not (a == 7 and b == 6))</code> ir devintoje: <code>print(9, not a == 7 and b == 6)</code> eilutėse yra atvaizduojamas reiškinių grupavimo pavyzdys. Reiškinius Python’e galima sugrupuoti naudojant skliaustelius. Sugrupavę reiškinius, mes priverčiame Python’ą iš pradžių įvertinti reiškinius skliaustuose ir tik tada likusias reiškinio dalis. Atkreipk dėmesį, kad skliausteliai pakeitė loginės išraiškos vertinimo tvarką, todėl pasikeitė rezultatas.. Taip nutiko dėl to, kad operatorius <code>not</code> buvo pritaikytas reiškiniui skliausteliuose, vietoj to, kad būtų pritaikytas tik <code>a == 7</code> daliai.
	Parodysiu pavyzdį, kaip rašant kodą galima pritaikyti loginius operatorius:		Parodysiu pavyzdį, kaip rašant kodą galima pritaikyti loginius operatorius:

ArturasNik 12:31, 5 rugpjūčio 2025

2025-08-05T12:31:04Z

← Ankstesnė versija		15:31, 5 rugpjūčio 2025 versija
1 eilutė:		1 eilutė:
	{{navigation \|previous=Pasirinkimai \|next=Ciklai For}}		{{navigation \|previous=Pasirinkimai \|next=Ciklai For}}

			=== Ką išmoksi šiame skyriuje? ===
			* Kas yra loginė reikšmė <code>True</code> ir <code>False</code>
			* Kaip veikia loginiai operatoriai: <code>and</code>, <code>or</code>, <code>not</code>
			* Kada naudojamas „tingus“ įvertinimas (short-circuit evaluation)
			* Kaip grupuoti sąlygas su skliausteliais
			* Kaip palyginti tekstus ar skaičius naudojant loginę logiką
			* Kaip Python interpretuoja loginę reikšmę įvairiems objektams
			* Kokios yra dažniausios loginės klaidos pradedantiesiems
			* Kaip parašyti programas su keliomis susijusiomis loginėmis sąlygomis


	[[Vaizdas:TrueFalse.png\|center\|frameless\|953x953px]]		[[Vaizdas:TrueFalse.png\|center\|frameless\|953x953px]]

Martynas 14:01, 3 balandžio 2025

2025-04-03T14:01:24Z

← Ankstesnė versija		17:01, 3 balandžio 2025 versija
295 eilutė:		295 eilutė:


	3. ~~Parašyk programą~~, ~~kuri paprašytų sukurti stiprų slaptažodį. Reikalavimai stipriam slaptažodžiui~~:		3. Asmuo gali gauti paskolą, jei:

	* ~~Jis turėtų būti sudarytas iš~~ daugiau ~~nei 6 simbolių~~		* jo amžius yra '''18 metų ar daugiau''', '''ir'''
	* ~~Jis turėtų turėti bent vieną skaitmenį~~		* jo mėnesinės pajamos yra '''daugiau nei 1000''', '''ir'''
	* ~~Jis turėtų turėti bent vieną specialų simbolį iš šio sąrašo: !#$?~~		* jis '''nėra skolingas''' kitur.

			Parašyk programą, kuri paprašo įvesti:

	~~Programa turėtų išvesti, ar slaptažodis pakankamai stiprus, ar ne.~~		# Amžių
			# Pajamas
			# Ar žmogus turi skolų?

			Ir praneša, ar gali gauti paskolą.
	{\| class="mw-collapsible mw-collapsed wikitable"		{\| class="mw-collapsible mw-collapsed wikitable"
	! colspan=2 \| Sprendimas		! colspan="2" \| Sprendimas
	\|-		\|-
	\|		\|
	<syntaxhighlight lang="python">		<syntaxhighlight lang="python">
	~~def ar_turi_skaičių~~(~~slaptažodis~~):		amžius = int(input("Įveskite savo amžių: "))
	~~skaičiai~~ = "~~0123456789~~"		pajamos = float(input("Įveskite savo mėnesines pajamas: "))
	~~rezultatas~~ = ~~False~~		turi_skolų = input("Ar turite skolų? (taip/ne): ") == "taip"
	~~for raidė in slaptažodis:~~
	~~if raidė in skaičiai:~~
	~~rezultatas = True~~
	~~break~~
	~~return rezultatas~~

	~~def ar_turi_simbolį~~(~~slaptažodis~~):
	~~simboliai~~ = "~~!#$?~~"
	~~rezultatas = False~~
	~~for raidė in slaptažodis:~~
	~~if raidė in simboliai:~~
	~~rezultatas = True~~
	~~break~~
	~~return rezultatas~~

	~~def ar_slaptažodis_stiprus(slaptažodis):~~		if amžius >= 18 and pajamos > 1000 and not turi_skolų:
	~~ar_užtenka_simbolių = len(slaptažodis)~~ > 6		print("Paskola suteikiama.")
	~~ar_yra_skaitmuo = ar_turi_skaičių(slaptažodis)~~
	~~ar_yra_simbolis~~ = ~~ar_turi_simbolį(slaptažodis)~~
	~~return ar_užtenka_simbolių~~ and ~~ar_yra_skaitmuo~~ and ~~ar_yra_simbolis~~


	~~įvestas_slaptažodis = input("Įvesk slaptažodį: ")~~
	~~ar_stiprus = ar_slaptažodis_stiprus(įvestas_slaptažodis)~~

	~~if ar_stiprus~~:
	print ("~~Slaptažodis pakankamai stiprus~~")
	else:		else:
	print ("~~Slaptažodis nepakankamai stiprus~~")		print("Paskola nesuteikiama.")
	</syntaxhighlight>		</syntaxhighlight>
	\|-		\|-

Martynas 13:53, 3 balandžio 2025

2025-04-03T13:53:16Z

← Ankstesnė versija		16:53, 3 balandžio 2025 versija
249 eilutė:		249 eilutė:

	=== Pratimai ===		=== Pratimai ===
	1. Parašyk programą, ~~kurioje vartotojas turi atspėti tavo vardą~~, ~~tačiau jie turės tik 3 spėjimus tai padaryti iki kol programa bus uždaryta~~.		1. Durys atsirakina tik tada, kai:

			* yra įvestas teisingas kodas '''ir'''
			* durys '''nėra užblokuotos'''.

			Parašyk programą, kuri paprašo vartotojo įvesti durų kodą ir paklausia, ar durys yra užblokuotos. Tada praneša, ar duris galima atidaryti.
	{\| class="mw-collapsible mw-collapsed wikitable"		{\| class="mw-collapsible mw-collapsed wikitable"
	! colspan=2 \| Sprendimas		! colspan="2" \| Sprendimas
	\|-		\|-
	\|		\|
	<syntaxhighlight lang="python">		<syntaxhighlight lang="python">
	~~print(~~"~~Pabandyk atspėti mano vardą!~~")		teisingas_kodas = "1234"
	~~kiekis = 1~~
	~~VARDAS~~ = "~~gilbertas~~"		ivestas_kodas = input("Įveskite durų kodą: ")
	~~spėjimas~~ = input("~~Koks mano vardas~~? ")		uzblokuotos = input("Ar durys užblokuotos? (taip/ne): ") == "taip"
	~~while kiekis < 3 and spėjimas.lower~~() ~~!= VARDAS~~: ~~# .lower visas didžiąsias raides teksto eilutėje pakeičia į mažąsias, todėl net jei vartotojas įves Gilbertas, tai vis tiek bus teisingas atsakymas~~
	~~print("Tu neteisus!~~")
	~~spėjimas~~ = ~~input(~~"~~Koks mano vardas?~~ ")
	~~kiekis = kiekis + 1~~

	if ~~spėjimas.lower() !~~= ~~VARDAS~~:		if ivestas_kodas == teisingas_kodas and not uzblokuotos:
	print("~~Tu neteisus!") # ši žinutė nėra atspausdinama trečiąjį bandymą, todėl mes tai padarome dabar~~		print("Durys atrakintos.")
	~~print("Tu nebegali spėti~~.")
	else:		else:
	print("~~Taip! Mano vardas yra", VARDAS + "!~~")		print("Durų atidaryti negalima.")
	</syntaxhighlight>		</syntaxhighlight>
	\|-		\|-

Martynas 13:49, 3 balandžio 2025

2025-04-03T13:49:25Z

← Ankstesnė versija		16:49, 3 balandžio 2025 versija
1 eilutė:		1 eilutė:
	{{navigation \|previous=Pasirinkimai \|next=Ciklai For}}		{{navigation \|previous=Pasirinkimai \|next=Ciklai For}}
			[[Vaizdas:TrueFalse.png\|center\|frameless\|953x953px]]

	Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina:		Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina:
	<syntaxhighlight lang="python">		<syntaxhighlight lang="python">
111 eilutė:		113 eilutė:

	<syntaxhighlight lang="python">		<syntaxhighlight lang="python">
	~~sąrašas~~ = ["~~Gyvenimas~~", "~~Visata~~"~~, "Viskas", "Benas", "Liepa", "Gyvenimas",~~ "~~Liepa~~"]		amzius = int(input("Įveskite savo amžių: "))
			turi_bilieta = input("Ar turite bilietą? (taip/ne): ") == "taip"

	~~# kuriama sąrašo kopija. Peržiūrėk skyrių Daugiau apie sąrašus, kuriame sužinosi ką reiškia [:].~~		if amzius >= 18 and turi_bilieta:
	~~kopija~~ = ~~sąrašas[:]~~		print("Galite įeiti į renginį.")
	~~# surūšiuoti sąrašą~~		else:
	~~kopija.sort()~~		print("Negalite įeiti į renginį.")
	~~ankstesnis = kopija[0]~~
	~~del kopija[0]~~

	~~kiekis = 0~~

	~~# sąraše surask vienodus elementus~~
	~~while kiekis < len(kopija)~~ and ~~kopija[kiekis] != ankstesnis~~:
	~~ankstesnis = kopija[kiekis]~~
	~~kiekis = kiekis + 1~~

	~~# Jei nėra atitikmens tuomet kiekis negali būti < len~~
	~~# kadangi ciklas kol bus vykdomas tol, kol kiekis < len~~
	~~# ir nėra rastas atitikmuo~~

	~~if kiekis < len~~(~~kopija~~):
	print("~~Pirmasis atitikmuo:~~"~~, ankstesnis~~)
	</syntaxhighlight>		</syntaxhighlight>

	~~Šios programos rezultatas:~~		[[Vaizdas:Bilietai.jpg\|center\|frameless\|965x965px]]
	~~Pirmasis atitikmuo: Gyvenimas~~

	~~Programa ieško vienodų elementų, tikrindama šią sąlygą: <code> while kiekis < len(kopija) and kopija~~[kiekis] nėra lygus ankstesnis </code>. Kai <code>kiekis</code> yra didesnis už paskutinio <code>kopija</code> sąrašo elemento indeksą arba, kai atsiranda sutampantis elementas, operatorius <code>and</code> nebėra tiesa, todėl ciklas pasibaigia. <code>if</code> sakinys patikrina ar ciklas <code>while</code> pasibaigė dėl to, kad buvo rastas sutampantis elementas.

	Šioje programoje yra panaudotas dar vienas <code>and</code> operatoriaus „triukas“. Jei dar kartą pažiūrėsi į operatoriaus <code>and</code> lentelę pamatysi, jog trečioje eilutėje yra netiesa ir netiesa. Jei <code>kiekis >= len(kopija)</code> (kitais žodžiais, jei <code>kiekis < len(kopija)</code> yra <code>False</code>), tada kodo dalis <code>kopija[~~kiekis]</code> nebus tikrinama~~. Taip yra todėl, kad Python’as žino, jei pirmasis teiginys yra klaidingas, tai abu jie nebegali būti teisingi. Šis „short circuit“ triukas yra naudingas tuomet, kai antrasis <code>and</code> operatoriaus reiškinys gali sukelti klaidą. Aš panaudojau pirmąjį reiškinį (<code>kiekis < len(kopija)</code>), kad patikrinčiau ar kintamasis <code>kiekis</code> yra validus sąrašo <code>kopija</code> indeksas. Jei manimi netiki, tuomet ištrink iš sąrašo elementus „Liepa“ ir „Gyvenimas“, sukeisk vietomis sąlygas <code>kiekis < len(kopija) and kopija[kiekis] ~~!= ankstesnis</code> (rašyk: <code>kopija[kiekis~~] ~~!= ankstesnis and kiekis < len(kopija)</code>) ir patikrink ar programa vis dar veikia, kaip turėtų.~~

	~~Loginiai operatoriai gali būti naudojami, kai mes norime patikrinti dvi arba daugiau skirtingų sąlygų vienu metu.~~

	=== Pastaba apie loginius operatorius ===		=== Pastaba apie loginius operatorius ===

ArturasNik: Naujas puslapis: {{navigation |previous=Pasirinkimai |next=Ciklai For}} Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina: a = 6 b = 7 c = 42 print(1, a == 6) print(2, a == 7) print(3, a == 6 and b == 7) print(4, a == 7 and b == 7) print(5, not a == 7 and b == 7) print(6, a == 7 or b == 7) print(7, a == 7 or b == 6) print(8, not (a == 7 and b == 6)) print(9, not...

2024-10-10T10:09:29Z

Naujas puslapis: {{navigation |previous=Pasirinkimai |next=Ciklai For}} Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina: <syntaxhighlight lang="python"> a = 6 b = 7 c = 42 print(1, a == 6) print(2, a == 7) print(3, a == 6 and b == 7) print(4, a == 7 and b == 7) print(5, not a == 7 and b == 7) print(6, a == 7 or b == 7) print(7, a == 7 or b == 6) print(8, not (a == 7 and b == 6)) print(9, not...

Naujas puslapis

{{navigation |previous=Pasirinkimai |next=Ciklai For}}
Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina:
<syntaxhighlight lang="python">
a = 6
b = 7
c = 42
print(1, a == 6)
print(2, a == 7)
print(3, a == 6 and b == 7)
print(4, a == 7 and b == 7)
print(5, not a == 7 and b == 7)
print(6, a == 7 or b == 7)
print(7, a == 7 or b == 6)
print(8, not (a == 7 and b == 6))
print(9, not a == 7 and b == 6)
</syntaxhighlight>

Šios programos išvestis yra:

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

Galvoje, turbūt, jau sukasi mintis: kas čia ką tik įvyko? Paaiškinsiu, kaip veikia kiekviena eilutė, kad mintys susidėliotų į savas vietas. Mano programoje gausu <code>print</code> sakinių, iš kurių kiekvienas išspausdina skaičių ir loginę reikšmę. Skaičius man padeda suprasti, kurio <code>print</code> sakinio rezultatas tai yra. Atkreipk dėmesį, kad kiekvienoje išvesties eilutėje yra žodis <code>False</code> (Klaidinga) arba <code>True</code> (Teisinga), o Python'e kiekviena loginė reikšmė <code>False</code> gali būti užrašoma skaičiumi 0, o <code>True</code> 1.

















Eilučių:

<syntaxhighlight lang="python">
print(1, a == 6)
print(2, a == 7)
</syntaxhighlight>

rezultatas atitinkamai yra <code>True</code> ir <code>False</code>, kadangi pirmasis reiškinys yra teisingas, o antrasis yra klaidingas. Trečioji eilutė: <code>print(3, a == 6 and b == 7)</code> - šiek tiek skiriasi nuo prieš tai buvusių - joje yra naudojamas operatorius <code>and</code>. Loginis operatorius <code>and</code> grąžina rezultatą <code>True</code> tik tada, kai reiškiniai iš abiejų <code>and</code> pusių yra teisingi, kitu atveju visas reiškinys bus klaidingas ir grąžins <code>False</code>. Ketvirtoje eilutėje: print(4, a == 7 and b == 7) tik vienas iš reiškinių yra teisingas, dėl to eilutės rezultatas yra <code>False</code>. Operatoriaus <code>and</code> galimi rezultatai gali būti apibrėžti tokia lentele:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>and</code> True
|True
|-
|True <code>and</code> False
|False
|-
|False <code>and</code> True
|False
|-
|False <code>and</code> False
|False
|}

Atkreipk dėmesį, jei pirmas reiškinys yra klaidingas, tai Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys yra klaidingas. Parašyk šias eilutes ir paleisk programą: <code>False and print("Labas")</code> ir palygink rezultatą su šios eilutės <code>True and print("Labas")</code> rezultatu. Techniškai tai yra vadinama sutrumpintos grandies įvertinimas (short-circuit evaluation).
Penktoje eilutėje, <code>print(5, not a == 7 and b == 7)</code>, yra naudojamas <code>not</code> operatorius. <code>not</code> suteikia priešingą reikšmę reiškiniui (reiškinys taip pat galėtų būti užrašomas taip: <code> print(5, a != 7 and b == 7)</code>). Štai lentelė apibrėžianti operatoriaus <code>not</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|<code>not</code> True
|False
|-
|<code>not</code> False
|True
|}

Dvi toliau pateiktos eilutės: <code>print(6, a == 7 or b == 7)</code> ir <code>print(7, a == 7 or b == 6)</code> naudoja operatorių <code>or</code>. Pastarasis operatorius grąžina <code>True</code> jei pirmasis reiškinys yra teisingas arba, jei antrasis reiškinys yra teisingas, arba, jei abu reiškiniai yra teisingi. Jei nei vienas iš reiškinių nėra teisingas, tuomet yra grąžinamas False. Štai lentelė apibrėžianti operatoriaus <code>or</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>or</code> True
| True
|-
|True <code>or</code> False
|True
|-
|False <code>or</code> True
|True
|-
|False <code>or</code> False
| False
|}

Turėk omeny, jei pirmasis reiškinys yra teisingas Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys bus teisingas. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code>, jei bent vienas iš reiškinių yra teisingas, tuomet viso reiškinio galutinis rezultatas bus teisingas. Pirmoji dalis yra teisinga, todėl antroji dalis gali būti klaidinga arba teisinga, tačiau visa išraiška vis dar teisinga.

Aštuntoje: <code>print(8, not (a == 7 and b == 6))</code> ir devintoje: <code>print(9, not a == 7 and b == 6)</code> eilutėse yra atvaizduojamas reiškinių grupavimo pavyzdys. Reiškinius Python’e galima sugrupuoti naudojant skliaustelius. Sugrupavę reiškinius, mes priverčiame Python’ą iš pradžių įvertinti reiškinius skliaustuose ir tik tada likusias reiškinio dalis. Atkreipk dėmesį, kad skliausteliai pakeitė reiškinį iš neteisingo į teisingą. Taip nutiko dėl to, kad operatorius <code>not</code> buvo pritaikytas reiškiniui skliausteliuose, vietoj to, kad būtų pritaikytas tik <code>a == 7</code> daliai.
Parodysiu pavyzdį, kaip rašant kodą galima pritaikyti loginius operatorius:

<syntaxhighlight lang="python">
sąrašas = ["Gyvenimas", "Visata", "Viskas", "Benas", "Liepa", "Gyvenimas", "Liepa"]

# kuriama sąrašo kopija. Peržiūrėk skyrių Daugiau apie sąrašus, kuriame sužinosi ką reiškia [:].
kopija = sąrašas[:]
# surūšiuoti sąrašą
kopija.sort()
ankstesnis = kopija[0]
del kopija[0]

kiekis = 0

# sąraše surask vienodus elementus
while kiekis < len(kopija) and kopija[kiekis] != ankstesnis:
ankstesnis = kopija[kiekis]
kiekis = kiekis + 1

# Jei nėra atitikmens tuomet kiekis negali būti < len
# kadangi ciklas kol bus vykdomas tol, kol kiekis < len
# ir nėra rastas atitikmuo

if kiekis < len(kopija):
print("Pirmasis atitikmuo:", ankstesnis)
</syntaxhighlight>

Šios programos rezultatas:
Pirmasis atitikmuo: Gyvenimas

Programa ieško vienodų elementų, tikrindama šią sąlygą: <code> while kiekis < len(kopija) and kopija[kiekis] nėra lygus ankstesnis </code>. Kai <code>kiekis</code> yra didesnis už paskutinio <code>kopija</code> sąrašo elemento indeksą arba, kai atsiranda sutampantis elementas, operatorius <code>and</code> nebėra tiesa, todėl ciklas pasibaigia. <code>if</code> sakinys patikrina ar ciklas <code>while</code> pasibaigė dėl to, kad buvo rastas sutampantis elementas.

Šioje programoje yra panaudotas dar vienas <code>and</code> operatoriaus „triukas“. Jei dar kartą pažiūrėsi į operatoriaus <code>and</code> lentelę pamatysi, jog trečioje eilutėje yra netiesa ir netiesa. Jei <code>kiekis >= len(kopija)</code> (kitais žodžiais, jei <code>kiekis < len(kopija)</code> yra <code>False</code>), tada kodo dalis <code>kopija[kiekis]</code> nebus tikrinama. Taip yra todėl, kad Python’as žino, jei pirmasis teiginys yra klaidingas, tai abu jie nebegali būti teisingi. Šis „short circuit“ triukas yra naudingas tuomet, kai antrasis <code>and</code> operatoriaus reiškinys gali sukelti klaidą. Aš panaudojau pirmąjį reiškinį (<code>kiekis < len(kopija)</code>), kad patikrinčiau ar kintamasis <code>kiekis</code> yra validus sąrašo <code>kopija</code> indeksas. Jei manimi netiki, tuomet ištrink iš sąrašo elementus „Liepa“ ir „Gyvenimas“, sukeisk vietomis sąlygas <code>kiekis < len(kopija) and kopija[kiekis] != ankstesnis</code> (rašyk: <code>kopija[kiekis] != ankstesnis and kiekis < len(kopija)</code>) ir patikrink ar programa vis dar veikia, kaip turėtų.

Loginiai operatoriai gali būti naudojami, kai mes norime patikrinti dvi arba daugiau skirtingų sąlygų vienu metu.

=== Pastaba apie loginius operatorius ===
Dažna pradedančiųjų programuotojų klaida yra neteisingas supratimas, kaip veikia loginiai operatoriai ir kaip juos „skaito“ Python'o interpretatorius. Pavyzdžiui: vos tik sužinojus apie operatorius <code>and</code> ir <code>or</code>, galima pagalvoti, kad išraiška <code>x == ('a' or 'b')</code> patikrins, ar kintamasis <code>x</code> yra lygus <code>a</code> arba kintamasis <code>x</code> lygus <code>b</code>, tačiau taip nėra. Norint suprasti, apie ką kalbu, pradėk interaktyvią sesiją su interpretatoriumi ir įvesk šias išraiškas:

>>> 'a' == ('a' or 'b')
>>> 'b' == ('a' or 'b')
>>> 'a' == ('a' and 'b')
>>> 'b' == ('a' and 'b')

Štai yra rezultatai, kurie nėra intuityvūs:

>>>''' 'a' == ('a' or 'b')'''
True
>>>''' 'b' == ('a' or 'b')'''
False
>>>''' 'a' == ('a' and 'b')'''
False
>>>''' 'b' == ('a' and 'b')'''
True

Šiuo momentu gali pasirodyti, jog operatoriai <code>and</code> ir <code>or</code> veikia klaidingai. Neatrodo logiška, jog pirmuose reiškiniuose <code>'a'</code> yra lygu <code>'a'</code> arba <code>'b'</code>, tačiau <code>'b'</code> nėra lygu <code>'a'</code> arba <code>'b'</code>. Taip pat yra ir su paskutiniu reiškiniu - jis neatrodo teisingas, nes <code>'b'</code> yra lygus <code>'a'</code> ir <code>'b'</code>. Išsiaiškinus, kaip veikia Python’o interpretatorius pasidaro aišku, kodėl gavome būtent tokius rezultatus.

Kai Python’o interpretatorius „pamato“ reiškinį, kuriame yra naudojamas <code>or</code>, jis paima pirmąjį teiginį ir patikrina ar jo rezultatas yra <code>True</code>. Jei pirmasis teiginys yra <code>True</code>, tuomet Python’as grąžina to teiginio rezultatą, netikrindamas antrojo. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code> užtenka patikrinti ar pirmasis teiginys yra teisingas, nes tada mes jau žinome, kad visas reiškinys yra teisingas ir programai nebereikia papildomai tikrinti antrojo. Iš kitos pusės, jei pirmasis teiginys grąžina <code>False</code>, tada Python’as turi patikrinti ir antrojo teiginio rezultatą bei grąžinti jo reikšmę. Antrasis teiginys nusako visos išraiškos rezultatą, kadangi pirmoji pusė buvo klaidinga. Šis interpretatoriaus „tingus“ įvertinimas vadinamas "short circuiting" ir yra įprastas būdas įvertinti logines išraiškas daugelyje programavimo kalbų.

Panašiai veikia ir operatorius <code>and</code>: Python’as naudoja, "short circuit" techniką, kad pagreitintų išraiškos įvertinimą. Jei pirmasis teiginys yra klaidingas, tada visas reiškinys yra klaidingas. Kitu atveju, jei pirmasis teiginys yra teisingas, tada Python’as patikrina antrąjį ir grąžina galutinę reikšmę.

Reiktų atkreiptį dėmesį į vieną niuansą: ne tik loginių išraiškų rezultatai gali būti apibrėžiami <code>True</code> arba <code>False</code> reikšmėmis. Norėdami patikrinti bet kurio objekto <code>x</code> loginę reikšmę, galite naudoti funkciją <code>bool(x)</code>. Žemiau yra pateikiama lentelė, kurioje yra pavyzdžiai, kokiems objektams Python’as priskiria <code>True</code> arba <code>False</code>:

{| class="wikitable"
|-
!True !!False
|-
|True ||False
|-
|1 ||0
|-
|Skaičiai kitokie nei nulis ||Tekstinė eilutė 'None'
|-
|Ne tuščios tekstinės eilutės ||Tuščios tekstinės eilutės
|-
|Sąrašai (lists) turintys elementų ||Sąrašai (lists) neturintys elementų
|-
|Žodynai (dictionaries) turintys elementų ||Žodynai (dictionaries) neturintys elementų
|}

Dabar galime suprasti gluminančius rezultatus, kuriuos gavome, kai anksčiau išbandėme logines išraiškas. Pažiūrėkime, ką Python'o interpretatorius „mato“, eidamas per šį kodą:

'''Pirmasis atvejis:'''
>>>''' 'a' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'a' == 'a' ''' # teksto eilutė 'a' yra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra True
True

'''Antrasis atvejis:'''
>>>''' 'b' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'b' == 'a' ''' # teksto eilutė 'b' nėra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra False
False

'''Trečiasis atvejis:'''
>>>''' 'a' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' and 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'a' == 'b' ''' # teksto eilutė 'a' nėra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra False
False

'''Ketvirtasis atvejis:'''
>>>''' 'b' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose:
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'b' == 'b' ''' # teksto eilutė 'b' yra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra True
True

Taigi, Python’as tikrai teisingai įvertino duotuosius reiškinius, kurių rezultatai iš pradžių neatrodė akivaizdūs. Kaip minėjau anksčiau, svarbu atpažinti, kokį rezultatą tavo loginė išraiška grąžins ir kodėl.

Grįžtant prie pradinių reiškinių, štai kaip juos turėtum aprašyti, kad jie grąžintų reikšmes, kurių tikiesi:

>>>''' 'a' == 'a' or 'a' == 'b' '''
True
>>>''' 'b' == 'a' or 'b' == 'b' '''
True
>>>''' 'a' == 'a' and 'a' == 'b' '''
False
>>>''' 'b' == 'a' and 'b' == 'b' '''
False

Įvertinus šiuos reiškinius yra gaunamos logines reikšmes <code>True</code> arba <code>False</code>, o ne teksto eilutės, kad galėtume gauti teisingus palyginimo rezultatus.

=== Pavyzdžiai ===
'''slaptazodis1.py'''
<syntaxhighlight lang="python">
## Ši programa prašo vartotojo prisijungimo vardo ir slaptažodžio.
# Kai vartotojas juos įveda, programa įvertina ar jis gali prisijungti.

vardas = input("Koks tavo vardas? ")
slaptažodis = input("Koks tavo slaptažodis? ")
if vardas == "Benas" and slaptažodis == "Penktadienis":
print("Sveikas, Benai!")
elif vardas == "Jonas" and slaptažodis == "Kietas":
print("Sveikas, Jonai!")
else:
print("Aš tavęs nepažįstu.")
</syntaxhighlight>

Pavyzdiniai rezultatai:

Koks tavo vardas? '''Benas'''

Koks tavo slaptažodis? '''Penktadienis'''

Sveikas, Benai!

Koks tavo vardas? '''Andrius'''

Koks tavo slaptažodis? '''Pinigai'''

Aš tavęs nepažįstu.

=== Pratimai ===
1. Parašyk programą, kurioje vartotojas turi atspėti tavo vardą, tačiau jie turės tik 3 spėjimus tai padaryti iki kol programa bus uždaryta.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
print("Pabandyk atspėti mano vardą!")
kiekis = 1
VARDAS = "gilbertas"
spėjimas = input("Koks mano vardas? ")
while kiekis < 3 and spėjimas.lower() != VARDAS: # .lower visas didžiąsias raides teksto eilutėje pakeičia į mažąsias, todėl net jei vartotojas įves Gilbertas, tai vis tiek bus teisingas atsakymas
print("Tu neteisus!")
spėjimas = input("Koks mano vardas? ")
kiekis = kiekis + 1

if spėjimas.lower() != VARDAS:
print("Tu neteisus!") # ši žinutė nėra atspausdinama trečiąjį bandymą, todėl mes tai padarome dabar
print("Tu nebegali spėti.")
else:
print("Taip! Mano vardas yra", VARDAS + "!")
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri paprašytų įvesti du skaičius. Programa turėtų išvesti, ar abu skaičiai didesni už 10, ar abu skaičiai mažesni už 10, ar vienas didesnis, kitas mažesnis.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
pirmas_skaičius = int(input("Įvesk pirmą skaičių: "))
antras_skaičius = int(input("Įvesk antrą skaičių: "))

if pirmas_skaičius > 10 and antras_skaičius > 10:
print ("Abu skaičiai didesni nei 10")
elif pirmas_skaičius < 10 and antras_skaičius < 10:
print ("Abu skaičiai mažesni nei 10")
else:
print ("Vienas iš skaičių mažesnis nei 10")
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri paprašytų sukurti stiprų slaptažodį. Reikalavimai stipriam slaptažodžiui:

* Jis turėtų būti sudarytas iš daugiau nei 6 simbolių
* Jis turėtų turėti bent vieną skaitmenį
* Jis turėtų turėti bent vieną specialų simbolį iš šio sąrašo: !#$?

Programa turėtų išvesti, ar slaptažodis pakankamai stiprus, ar ne.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def ar_turi_skaičių(slaptažodis):
skaičiai = "0123456789"
rezultatas = False
for raidė in slaptažodis:
if raidė in skaičiai:
rezultatas = True
break
return rezultatas

def ar_turi_simbolį(slaptažodis):
simboliai = "!#$?"
rezultatas = False
for raidė in slaptažodis:
if raidė in simboliai:
rezultatas = True
break
return rezultatas

def ar_slaptažodis_stiprus(slaptažodis):
ar_užtenka_simbolių = len(slaptažodis) > 6
ar_yra_skaitmuo = ar_turi_skaičių(slaptažodis)
ar_yra_simbolis = ar_turi_simbolį(slaptažodis)
return ar_užtenka_simbolių and ar_yra_skaitmuo and ar_yra_simbolis

įvestas_slaptažodis = input("Įvesk slaptažodį: ")
ar_stiprus = ar_slaptažodis_stiprus(įvestas_slaptažodis)

if ar_stiprus:
print ("Slaptažodis pakankamai stiprus")
else:
print ("Slaptažodis nepakankamai stiprus")
</syntaxhighlight>
|-
|}

{{navigation |previous=Pasirinkimai |next=Ciklai For}}
[[Category:Python Vadovėlis]]