Vadovėlis/Loginiai reiškiniai - Versijų istorija

ArturasNik 08:13, 16 balandžio 2023

2023-04-16T08:13:55Z

← Ankstesnė versija		11:13, 16 balandžio 2023 versija
365 eilutė:		365 eilutė:

	{{navigation \|previous=Ciklai For \|next=Žodynai}}		{{navigation \|previous=Ciklai For \|next=Žodynai}}
	~~{{BookCat}}~~		[[Category:Python Vadovėlis]]

Martynas 15:49, 9 vasario 2023

2023-02-09T15:49:03Z

← Ankstesnė versija		18:49, 9 vasario 2023 versija
276 eilutė:		276 eilutė:
	print("Pabandyk atspėti mano vardą!")		print("Pabandyk atspėti mano vardą!")
	kiekis = 1		kiekis = 1
	~~vardas~~ = "gilbertas"		VARDAS = "gilbertas"
	spėjimas = input("Koks mano vardas? ")		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		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!")		print("Tu neteisus!")
	spėjimas = input("Koks mano vardas? ")		spėjimas = input("Koks mano vardas? ")
	kiekis = kiekis + 1		kiekis = kiekis + 1

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

	</syntaxhighlight>		</syntaxhighlight>
	\|-		\|-

Monika: Pridėta užduočių

2023-01-24T16:06:28Z

Pridėta užduočių

@@ 268 eilutė: / 268 eilutė: @@
 === Pratimai ===
-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.
+. 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 &nbsp;
@@ 289 eilutė: / 289 eilutė: @@
      print("Taip! Mano vardas yra", vardas + "!")
 </syntaxhighlight>
 |-

Admin: Naujas puslapis: {{navigation |previous=Ciklai For |next=Žodynai}} Š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 a =...

2022-12-12T19:56:58Z

Naujas puslapis: {{navigation |previous=Ciklai For |next=Žodynai}} Š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 =...

Naujas puslapis

{{navigation |previous=Ciklai For |next=Žodynai}}
Š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 ===
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>
|-
|}

{{navigation |previous=Ciklai For |next=Žodynai}}
{{BookCat}}