Python ๊ธฐ์ด
Python์ ํ๋ก๊ทธ๋๋ฐ "์ธ์ด"์ ๋๋ค. ๊ฐ์ธ์ ์ผ๋ก ์ฌ๋์ ์ธ์ด์ ๊ฐ์ฅ ๊ทผ์ ํ ํํ๋ฅผ ๋ ๊ณ ์๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๊ฐ Python์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค. ์๋์ ์ฝ๋๋ฅผ ์ ๊น ์ดํด๋ณผ๊น์?
x = 3
if x ==3: print("correct")
์ฝ๋ฉ์ ๋ํ ์ง์์ด ์์ด๋ ๋๋ถ๋ถ์ ์ฌ๋๋ค์ ์์ ์ฝ๋๊ฐ ๋ฌด์จ ๋ด์ฉ์ธ์ง ์ง๊ด์ ์ผ๋ก ์ ์ ์์ต๋๋ค. ์์ง ์ ๋ชจ๋ฅด์๊ฒ ์ผ๋ฉด ์ค๋ช ๊ณผ ํจ๊ป ์ฝ๋๋ฅผ ๋ค์ ์ดํด๋ณผ๊น์?
`x=3` : x๋ 3์ด๋ค.
`if x ==3: print("correct")` : x๊ฐ 3์ด๋ผ๋ฉด "correct"๋ผ๋ ๊ฒ์ ํ๋ฆฐํธํด๋ผ.
Python์ด ๋ค๋ฅธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋นํด์ ์ง๊ด์ ์ด๊ณ , ๋ฐฐ์ฐ๊ธฐ ์ฝ๋ค๋ ๋ง์ ์ด๋์ ๋ ๊ณต๊ฐ์ด ๋์ จ์ ๊ฒ ๊ฐ์ต๋๋ค. ๊ทธ๋ ๋ค๋ฉด ์ธ์ด๋ฅผ ์ ๋ฐฐ์ฐ๊ธฐ ์ํด์๋ ๋ฌด์์ ํด์ผ ํ ๊น์?
์ฐ๋ฆฌ๊ฐ ์ฒ์ ์ธ์ด๋ฅผ ๋ฐฐ์ธ ๋, ๊ฐ์ฅ ๋จผ์ ํ๋ ๊ฒ์ ๊ธฐ๋ณธ์ ์ธ ๋ฌธ์ ์ฒด๊ณ(์ํ๋ฒณ)์ ๋ฌธ๋ฒ์ ๋ํด์ ๋ฐฐ์๋๋ค. Python ๋ํ ๋ค๋ฅธ ์ธ์ด์ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ณ ์ ์ ๊ธฐ๋ณธ ๊ตฌ์ฑ ์์๊ฐ ์์ผ๋ฉฐ ๋ฌธ๋ฒ์ด๋ผ๋ ๊ฒ์ด ์์ต๋๋ค. ์ด๋ฒ ์ฅ์์๋ Python์ ์ํ๋ฒณ๊ณผ ๋ฌธ๋ฒ์ ๋ํด ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
์ ๋ ฅ๊ณผ ์ถ๋ ฅ (Input / Output)
ํ๋ก๊ทธ๋๋ฐ์์ ์ ๋ ฅ(Input)์ ํ๋ก๊ทธ๋จ์ ์ ๊ณต๋๋ ๋ฐ์ดํฐ๋ ์ ๋ณด๋ฅผ ์๋ฏธํ๋ฉฐ, ์ถ๋ ฅ(Output)์ ์ ๋ ฅ์ ์ฒ๋ฆฌํ ํ์ ํ๋ก๊ทธ๋จ์ด ์์ฑํ๋ ๊ฒฐ๊ณผ๋ ์๋ต์ ๋งํฉ๋๋ค. Python์์๋ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ฌ์ฉ์ ๋ฐ ์ธ๋ถ ํ๊ฒฝ๊ณผ ์ํธ์์ฉํ๋ ๋ฐ์ ๊ธฐ๋ณธ์ ์ธ ๊ฐ๋ ์ ๋๋ค. ์ ๋ ฅ์ ๋ด๊ฐ ์ปดํจํฐ์๊ฒ ํ๋ ๋ง, ์ถ๋ ฅ์ ์ปดํจํฐ์ ๋ต๋ณ์ด๋ผ๊ณ ์ผ๋จ ์ดํดํด ๋์๋ฉด ํธํ ๊ฒ ๊ฐ์ต๋๋ค.
ํ์ ์ฌ์ ์ง์
๊ณต๋ถ๋ฅผ ํ๊ธฐ ์ ์ ์ข ์ด์ ์ฐํ์ ์ค๋นํ๊ณ ๊ฒ์ ๊ฒ์ด ๊ธ์จ๊ณ ํฐ ๊ฒ์ด ์ข ์ด์ ๋ํ ์์์ด ํ์ํ๋ฏ์ด ํ์ด์ฌ ๋ํ ๊ณต๋ถํ๊ธฐ์ ์์ ํ์์ ์ผ๋ก ์๊ณ ์์ด์ผ ํ ์ธ ๊ฐ์ง ๋ด์ฉ์ด ์์ต๋๋ค.
1. ๋ณ์, ๊ฐ, ํ ๋น (Variable, Value, Assignment)
ํ์ด์ฌ ์ฝ๋์ ์ ๋ฐ ์ ๋๋ ๋ณ์์ ํน์ ํ ๊ฐ์ ํ ๋น(assign) ํ๋ ์์ ์ผ ๊ฒ์ ๋๋ค. ํ ๋น์ด๋ผ๋ ๋จ์ด์ ์๋ฏธ๋ "์ ์ฅํ๋ค" ์ ๋๋ก ์ดํดํ์ ๋ ๋ฌด๋ฐฉํฉ๋๋ค. ์ ์ฅํ ๋ด์ฉ์ ๊ฐ, ์ ์ฅ ํ ์์น๋ฅผ ๋ณ์ ๋ผ๊ณ ์ดํดํ์๋ฉด ๋ ๊ฒ ๊ฐ์ต๋๋ค.
x = 1
์์ ์ฝ๋ x = 1์ด๋ผ๋ ์ฝ๋๋ ์ํ ์๊ฐ์ ๋ง์ด ์กธ์๋๋ผ๋(?) ์ง๊ด์ ์ผ๋ก ์ด๋ค ์๋ฏธ๋ฅผ ๊ฐ์ง๋ ์ง ์ ์ ์์ต๋๋ค. ๋ง ๊ทธ๋๋ก x ๋ 1์ด๋ผ๋ ๊ฐ์ ๊ฐ์ง๋ค๊ณ ์ ์๋ฅผ ํ ๊ฒ์ ๋๋ค. ์กฐ๊ธ ๋ ์์ด ๋ณด์ด๊ฒ ๋งํ์๋ฉด x ๋ผ๋ ๋ณ์์ 1์ด๋ผ๋๊ฐ์ ํ ๋นํ ๊ฒ์ ๋๋ค. ๋ค์๊ณผ ๊ฐ์ด, ํ๊บผ๋ฒ์ ์ฌ๋ฌ ๋ฒ์ ํ ๋น์ ํ ์๋ ์์ต๋๋ค.
x, y = 1, 2 # ๋ฐฉ๋ฒ 1: x์๋ 1, y์๋ 2๋ฅผ ๊ฐ๊ฐ ํ ๋น
a, b, c = [1 ,2, 3] # ๋ฐฉ๋ฒ 2: a์๋ 1, b์๋ 2, c์๋ 3์ ๊ฐ๊ฐ ํ ๋น
p, q, r = (1, 2, 3) # ๋ฐฉ๋ฒ 3: a์๋ 1, b์๋ 2, c์๋ 3์ ๊ฐ๊ฐ ํ ๋น
= ๊ธฐํธ๋ ์ํ์์ ๊ฐ๋ค ๋ผ๋ ์๋ฏธ๋ฅผ ๊ฐ์ง์ง๋ง, ํ์ด์ฌ๋ฟ๋ง ์๋๋ผ ๋๋ถ๋ถ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์๋ ํ ๋น ์ด๋ผ๋ ์๋ฏธ๋ก ์ฌ์ฉ๋ฉ๋๋ค. ํ์ด์ฌ์์๋ == ๊ธฐํธ๊ฐ ๊ฐ๋ค ๋ผ๋ ์๋ฏธ๋ฅผ ๊ฐ์ง๋๋ค. ์ด์ ๊ด๋ จํด์๋ ์ฌ์น์ฐ์ฐ์ ๋ํ ์ค๋ช ์์ ์์ธํ๊ฒ ๋ค๋ฃจ๋๋ก ํ๊ฒ ์ต๋๋ค.
2. ๋์ด์ฐ๊ธฐ, ๋ค์ฌ ์ฐ๊ธฐ, ์ค ๋ฐ๊ฟ (Space, Indentation, Line Break)
์ฐ๋ฆฌ๋ ๊ธ์ ์ฝ์ ๋ ๋ณดํต ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก, ์์์ ์๋๋ก ์์ ์ ์ด๋ํ๋ฉฐ ์ฝ์ต๋๋ค. ํ์ด์ฌ ๋ํ ๋ง์ฐฌ๊ฐ์ง์ ๋๋ค. ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ฝ์ผ๋ฉฐ, ํน์ํ ๊ฒฝ์ฐ๋ฅผ ์ ์ธํ๊ณ ๋ ํ ์ค์ ํ๋์ ๋ ๋ฆฝ์ ์ธ ์ฝ๋๋ก ์ทจ๊ธํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ํ์ด์ฌ์์ ๊ณต๋ฐฑ์ ๊ฐ๋ ์ฑ์ ์ํด ์ฃผ๋ก ์ฌ์ฉ๋ฉ๋๋ค. ๋ค์ฌ ์ฐ๊ธฐ๋ฅผ ์ํด์ ์ฌ์ฉํ ๊ฒฝ์ฐ 4์นธ, ํน์ Tab์ ํ ๋ฒ ๋๋ฌ์ ์ฌ์ฉํฉ๋๋ค.
x=1
x= 1
x = 1
x = 1
๋ค์ฌ ์ฐ๊ธฐ๋ "๋ฌธ๋ฒ์ ์์ํ๋ค"์ ์๋ฏธ๋ก ์ฌ์ฉ๋ฉ๋๋ค. ๋ค์ฌ ์ฐ๊ธฐ๋ฅผ ์ฌ์ฉํ ์ฝ๋๋ ๋ค์ฌ ์ฐ๊ธฐ๊ฐ ๋์ง ์์ ๊ฐ์ฅ ์ฒซ ๋ฒ์งธ ์์ ์ฝ๋์ ํฌํจ๋๋ฉฐ (์ด์ ๋ํ ๋ด์ฉ์ ๋ฐ๋ณต๋ฌธ, ์กฐ๊ฑด๋ฌธ์์ ์์ธํ๊ฒ ๋ค๋ฃจ๊ฒ ์ต๋๋ค) ์์ ์ฝ๋๋ ์ ๋ถ ๊ฐ์ ์๋ฏธ๋ฅผ ๊ฐ์ง๋๋ค.
Python์ ํฌํจํ ๋๋ถ๋ถ์ ์ฝ๋๋ ํ ์ค์ด ํ ๋ฌธ์ฅ์ผ๋ก์์ ์๋ฏธ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ๋ฌธ์ฅ์ ๋ง์น๊ธฐ ์ํด์๋ ๋ง์นจํ๋ฅผ ์ฐ์ง๋ง, python์ ๊ฒฝ์ฐ์๋ ํน๋ณํ ๊ฒฝ์ฐ๋ฅผ ์ ์ธํ๊ณ ๋ ์ค ๋ฐ๊ฟ์ ํ๋ฉด ํด๋น ์ค์์ ์ฝ๋์ ์๋ฏธ๊ฐ ๋์ด ๋ฉ๋๋ค.
3. ์ฃผ์/์ฝ๋ฉํธ
ํ์ด์ฌ ์ฝ๋๋ฅผ ์์ฑํ ๋, ํด์ํ๊ทธ (#)๋ฅผ ์ฌ์ฉํ๋ฉด ์ฃผ์์ ๋ฌ ์ ์์ต๋๋ค. ์ฃผ์์ ํ์ด์ฌ์ด ์ฝ๋๋ฅผ ์คํํ ๋ ๋ฌด์ํ๋ ๋ถ๋ถ์ ๋๋ค. ์ฃผ์์ ์ด์ฉํด์ ์ฝ๋์ ๋ํ ์ค๋ช ์ ์ ์ ์๋ ์๊ณ , ๋๊ฐ ์ผ๋์ง ๊ธฐ๋ก์ ํ ์๋ ์์ผ๋ฉฐ ๋ค์ํ ๋ฐฉ๋ฒ์ผ๋ก ํ์ฉํ ์ ์์ต๋๋ค. ํด์ํ๊ทธ (#) ๊ธฐ์ค์ผ๋ก ์ค๋ฅธ์ชฝ ๋ถ๋ถ๋ง ์ฃผ์ ์ฒ๋ฆฌ๊ฐ ๋๋ฉฐ, ํ ์ค์ฉ ์ฝ๋ฉํธ๋ฅผ ๋ฌ ์ ์์ต๋๋ค. ์๋ ์ฝ๋๋ฅผ ์คํํ๋ค๋ฉด x๋ 123์ด๋ผ๋ ๊ฐ์ ๊ฐ์ง์ง๋ง (ํ ๋น), y = 456 ๋ถ๋ถ์ ๋ฌด์๊ฐ ๋ฉ๋๋ค.
x = 123 # x์ 123 ํ ๋น
# y = 456
ํ์ด์ฌ ์๋ฃํ (Data Types)
ํ๊ธ์ ๋ฌธ์ ์ฒด๊ณ๋ ์์๊ณผ ๋ชจ์์ผ๋ก ๋์ด ์์ต๋๋ค. ์์์ ใฑ,ใด,ใท,... , ใ ์ผ๋ก ๊ตฌ์ฑ๋์ด ์๊ณ , ๋ชจ์์ ใ ,ใ ,ใ ,... , ใ ฃ ๋ก ๊ตฌ์ฑ์ด ๋์ด ์์ต๋๋ค. ์์๊ณผ ๋ชจ์์ ์กฐํฉ์ผ๋ก ๋จ์ด๋ฅผ ๋ง๋ค์ด๋ด๊ณ , ๋จ์ด๋ฅผ ์ ์ ํ ๋ฌธ๋ฒ์ ์ฌ์ฉํด์ ๋ฐฐ์น๋ฅผ ํ๋ฉด์ ๋ฌธ์ฅ์ ๋ง๋ค๊ณ , ๋ฌธ์ฅ์ด ๋ชจ์ฌ์ ๊ธ์ด ๋ฉ๋๋ค. ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ ๋น๋ก ์ธ์ด์ด์ง๋ง, ์ธ๊ฐ์ ์ธ์ด์๋ ์ฌ๋ญ ๋ค๋ฅธ ๋ฌธ์ ์ฒด๊ณ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ํ๊ธ์ ์์๊ณผ ๋ชจ์์ด ์๋ค๋ฉด, ํ์ด์ฌ์ ์ฌ๋ฌ ๊ฐ์ง ์๋ฃํ(Data Type)์ด ์์ต๋๋ค. ์ฌ๋ฌ ๊ฐ์ง์ ์๋ฃํ๊ณผ ํ์ด์ฌ ๋ฌธ๋ฒ์ ๊ธฐ๋ณธ์ ์ธ ์ดํด๋ง ์์ด๋ ๋ง์ ๊ฒ๋ค์ ํ ์ ์์ต๋๋ค.
๊ธฐ๋ณธ ์๋ฃํ
ํ์ด์ฌ์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์๋ฃํ ์๋ ์ธ ๊ฐ์ง์ ๋๋ค: - ์ซ์ํ (Numeric): ์ซ์ ํํ์ ์๋ฃ (์ ์, ์์, ๋ณต์์) - ๋ฌธ์์ด (String): ๋ฌธ์ ํํ์ ์๋ฃ (๋ฌธ์, ๋จ์ด) - ๋ ผ๋ฆฌํ (Boolean): ์ฐธ, ๊ฑฐ์ง
์์ธํ ์ค๋ช ์ ์์, ์ฐ์ ์ ์๋์ ์ฝ๋๋ฅผ ๋ณด๊ฒ ์ต๋๋ค.
x = 1 # int ์ ์ (integer) # ์ซ์ํ
y = "1" # str ๋ฌธ์์ด (string) # ๋ฌธ์ํ
z = True # bool ๋ถ๋ฆฐ (boolean) # ๋
ผ๋ฆฌํ
x = 1์ด๋ผ๋ ์ฒซ ๋ฒ์งธ ์ค์ ์ฝ๋๋ x ๋ผ๋ ๊ฐ์ 1 ์ด๋ผ๋ ๊ฐ์ ํ ๋นํ๋ค๋ ์๋ฏธ์ ๋๋ค.
๊ทธ๋ ๋ค๋ฉด y = "1"์ ๋ฌด์จ ์๋ฏธ์ผ๊น์? x = 1 ๊ณผ๋ ๋งค์ฐ ๋น์ทํด ๋ณด์ด์ง๋ง, " ๋ก 1์ด ๋๋ฌ์ธ์๋ค๋ ์ฐจ์ด์ ์ด ์์ต๋๋ค. ์ฐ๋ฆฌ๋๋ผ ๋ง์ด ์ ๋ค๋ฅด๊ณ ์ด ๋ค๋ฅด๋ฏ์ด ํ์ด์ฌ์์ "1"๊ณผ 1 ์ ๋ค๋ฆ ๋๋ค. " ํน์ ' ๋ก ๊ฐ์ผ ์๋ฃํ์ ์ซ์๊ฐ ์๋ ๋ฌธ์๋ก ์ทจ๊ธ๋ฉ๋๋ค. ๋ถ๋ฆฐ ์๋ฃํ, ํน์ ๋ ผ๋ฆฌํ ์๋ฃํ์ ๊ฐ๋จํฉ๋๋ค. True (์ฐธ) ํน์ False (๊ฑฐ์ง) ๋ผ๋ ๋ ๊ฐ์ง์ ๊ฐ๋ง ๊ฐ์ง ์ ์๋ ์๋ฃํ์ ๋๋ค.
์๋์ ์ฝ๋๋ ์์ ์ธ๊ธํ ์ธ ๊ฐ์ง ์๋ฃํ์ด ์ ๋ถ ํ์ฉ๋ฉ๋๋ค:
> a = 1
> b = '1'
> a == b
False
a == b์ ์๋ฏธ๋ ๋ณ์ a ์ ๋ณ์ b ๊ฐ == ๊ฐ๋ค ๋ผ๋ ๋ป์ ๋๋ค. a๋ 1์ด๊ณ , b ์ด๊ธฐ ๋๋ฌธ์ ๋น์ทํ ๊ฐ์ด์ง๋ง ์๋ฃํ์ ์ข ๋ฅ๊ฐ ๋ค๋ฅด๋ฏ๋ก ๊ฑฐ์ง์ด ๋ฉ๋๋ค. ๋ฐ๋ผ์ ๋ ผ๋ฆฌํ False ๊ฐ ์ฝ๋ ์คํ ๊ฒฐ๊ณผ๋ก ๋์ค๊ฒ ๋ฉ๋๋ค.
๊ธฐ๋ณธ ์๋ฃํ์ ์ฌ์น์ฐ์ฐ
๋ง์ , ๋บ์ , ๋๋์ , ๊ณฑ์ ์ ์ํ์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๊ฐ๋ ์ธ ์ฌ์น์ฐ์ฐ์ด๋ผ๊ณ ํฉ๋๋ค. ๊ธฐ๋ณธ ์๋ฃํ ๋ํ ์ซ์์ฒ๋ผ ์ฌ์น์ฐ์ฐ์ด ๊ฐ๋ฅํฉ๋๋ค. ์์ ๋ฅผ ํตํด์ ๊ฐ๊ฐ์ ์๋ฃํ์ ๋ง์ (+), ๋บ์ (-), ๊ณฑ์ (*), ๋๋์ (/)์ด ์ด๋ค ์๋ฆฌ๋ก ์๋ํ๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
์ซ์ (Numbers)
์ซ์ํ์ ์ฌ์น์ฐ์ฐ์ ์ํ์๊ฐ์ ๋ฐฐ์ ๋ ๊ฒ๊ณผ ๋์ผํฉ๋๋ค.
> x = 5
> x + 3 # ๋ง์
8
> x - 9 # ๋บ์
-4
> x * 5 # ๊ณฑ์
25
> x / 4 # ๋๋์
1.25
๋ฌธ์ (String)
์ผ๋ฐ์ ์ผ๋ก ์ฌ์น์ฐ์ฐ์ ๊ฐ์ ์๋ฃํ๋ผ๋ฆฌ๋ง ๊ฐ๋ฅํฉ๋๋ค. ("๋จ์"๋ผ๋ ๋จ์ด์ ์ซ์ 1์ ๋ํ๊ณ ๋บ ์ ์๋ ๊ฒ์ฒ๋ผ) ๊ทธ๋ฆฌ๊ณ ๋ฌธ์ํ์ ์ฌ์น์ฐ์ฐ์ ๋ง์ ๋ง ๊ฐ๋ฅํฉ๋๋ค. ๋ง์ ์ ์ ์ธํ ๋๋จธ์ง ๋บ์ , ๊ณฑ์ , ๋๋์ ์ ์๋ํ๋ค๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํฉ๋๋ค. ํ์ง๋ง, ๋ช ๊ฐ์ง ์์ธ์ ์ธ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค. ๋ฌธ์์ด์ ๊ฒฝ์ฐ ์ซ์ํ (์ ์), ๋ณผ๋ฆฐ๊ณผ์ ๊ณฑ์ ์ด ๊ฐ๋ฅํฉ๋๋ค.
> x = '5'
> x + 3 # ์๋ฌ # ๊ฐ์ ์๋ฃํ๋ผ๋ฆฌ๋ง ์ฐ์ฐ ๊ฐ๋ฅ
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
> x + '3' # ๋ง์
#
53
> x - '5' # ์๋ฌ # ๊ณฑ์
๊ณผ ๋๋์
๋ ๋ง์ฐฌ๊ฐ์ง๋ก ์๋ฌ๋ฐ์
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
> x * 4 # x ๋ณ์์ ํ ๋น๋ ๊ฐ์ 4๋ฒ ๋ฐ๋ณตํ๋ผ๋ ์๋ฏธ
'5555'
> y = True # ๋ถ๋ฆฐ์ True๋ ์ซ์ํ 1 ์ผ๋ก ์ทจ๊ธ๋จ
> z = False # ๋ถ๋ฆฐ์ False๋ ์ซ์ํ 0 ์ผ๋ก ์ทจ๊ธ๋จ
> x * y
'5'
> x * z
''
> l, o, t = "l", "o" , "t" # ๋ค์ค ํ ๋น
> l + o + t*2 + o # ์ฌ์น์ฐ์ฐ์ฒ๋ผ ๊ณฑ์
์ด ๋จผ์ ์คํ๋จ
'lotto'
๋ถ๋ฆฐ (Boolean)
๋ถ๋ฆฐํ ๋ฐ์ดํฐ๋ ์ฐธ, ๊ฑฐ์ง ๋๊ฐ์ง ๊ฐ์ ๊ฐ์ง๊ณ ์์ต๋๋ค. ํน์ ์กฐ๊ฑด์ผ ๋ ์ฝ๋๋ฅผ ์คํ์ํฌ ๋ ์ฃผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
๋ถ๋ฆฐํ์ ์กฐํฉ์ผ๋ก ๋ค์ํ ๊ตฌ์กฐ์ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
> A = True
> B = False
> A and B # False
> A or B # True
๋๊ธ