continue๋ฌธ๊ณผ break๋ฌธ์ ๊ธฐ๋ณธ์
๋๋ค! ํ์ง๋ง ์ด๋ ค์ด ๋ฌธ์ ์์ ๋ถ๊ธฐ๋ณ ์ผ์ด์ค๋ฅผ ์ ๋ถ๋ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๊ธฐ๋ณธ ๋ฌธ๋ฒ์ ํ์คํ๊ฒ ์๊ณ ์์ด์ผ ํ๋ ๋ถ๋ถ์
๋๋ค โ๏ธํ์ด์ฌ continue & break ๋ฌธ ์ด๋? ํ์ด์ฌ ํ๋ก๊ทธ๋๋ฐ์์ for๋ฌธ์ด๋ while๋ฌธ์ ์ฐ๋ค๋ณด๋ฉด ์ด๋ค ์กฐ๊ฑด์ผ๋ ๋ฐ๋ณต๋ฌธ ์์ฒด๋ฅผ ๋น ์ ธ๋์ค๊ฑฐ๋ ์ด๋ค ์กฐ๊ฑด์์๋ ๊ฑด๋๋ฐ์ด์ผ ํ๋ ์์ธ์ฌํญ์ด ์๊ธธ ๋๊ฐ ์์ต๋๋ค. ์ด๋ด๋ ์ฌ์ฉํ๋๊ฒ์ด continue & break ๋ฌธ ์
๋๋ค. โ๏ธcontinue๋ฌธ์ ์ด๋ค ์กฐ๊ฑด์ผ๋๋ ๋ฐ๋ณต๋ฌธ ์์ ๋ช
์๋ ์ํ ์ฝ๋๋ฅผ ๊ฑด๋๋ฐ๊ฒ ํ๊ณ ์๋ ์คํ ์ค์ด๋ for๋ฌธ ๋ฑ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋ค์ ๋์์ค๊ฒ ํฉ๋๋ค for route in routes: isFalse = False for i in range(1, int(dist) + 1):..
Python deque deque ๋ผ๋ ๊ฒ์ ์ฝ๊ฒ ๋งํ์๋ฉด ํ์ด์ฌ์ list ์ ๊ฐ์ด ์์๋ค์ ํ ๊ณณ์ ๋ด์๋๋ ๋ฐฐ์ด์ด๋ค. ํ์ด์ฌ์์ ํ queue๋ First In First Out (FIFO) ์ ๋ฐฉ์์ผ๋ก ์๋๋๋ค. ๋ฑ(๋ฐํ)๋ ํ๋ ํ์ด์ง๋ง ์๋ฐฉํฅ์ธ queue์ด๋ค. ์ ์ชฝ ๋ฐฉํฅ ๋ชจ๋์์ (์, ๋ค) ์์๋ฅผ ์ถ๊ฐ/ ์ ๊ฑฐํ ์ ์๋ค. List๋ ์๋๋ฐ ๊ตณ์ด deque๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๋ ? ๊ฐ๋ตํ๊ฒ ๋งํ์๋ฉด List ๋ณด๋ค deque์ ์๋๊ฐ ํจ์ฌ ๋น ๋ฅด๊ธฐ ๋๋ฌธ์ด๋ค. list๋ O(n) ์ ์๋, deque๋ O(1)์ ์๋์ด๋ค. ์๊ธฐ ํ์์ ๋ณด๋ค์ํผ O(1)์ ์๋๊ฐ ๊ฐ - ์ฅ ์ข์ best ์๋์ด๋ค. ๊ทธ๊ฒ ๋ฐ๋ก deque ! ์ฐ์ฐ์ด ๋ง์์๋ก ์์ธ ์ด์ ๊ฐ ์๋ค. ์ฒ์ deque์๊ณ ๋ฆฌ์ฆ์ ํ์ด๋ณด๋ฉฐ ์ ๋ฆฌ์คํธ..
1. ํ์ด์ฌ ์ ์ ๋ณํ - int() 2. ํ์ด์ฌ ์ค์ ๋ณํ - float() 3. ํ์ด์ฌ ๋ฌธ์์ด ๋ณํ - str() 4. ํ์ด์ฌ ๋ฌธ์ ๋ณํ - chr() 5. ํ์ด์ฌ ๋ถ๋ฆฌ์ธ ๋ณํ - bool() 1. python int int(x)๋ ์ธ์๋ก๋ค์ด์จ x๋ฅผ ์ ์ ํ์
์ผ๋ก ๋ฐํ์ ํด์ฃผ๋ ๊ธฐ๋ฅ์ ํฉ๋๋ค. int(์ ์)๊ฐ ๋ค์ด์ค๋ฉด ์ ์๋ฅผ ์ ์ ํ์
์ผ๋ก ๋ณํํ์ฌ ๋ฐํ์ ํด์ฃผ๊ณ int(๋ฌธ์์ด)์ด ๋ค์ด์ค๋ฉด ๋ฌธ์์ด์ ๋ง๋ ์ ์ ํ์
์ ๋ฐํํด ์ค๋๋ค. ๋ง์ฝ์ ๋ฐ๊ฟ์ ์๋ ๋ฌธ์์ด ์ด๋ผ๋ฉด ์ค๋ฅ๋ฅผ ๋ด๋ฑ์ต๋๋ค. ์ด๋ ๊ฒ ์ฐ๋ฆฌ๊ฐ ์์์ ์ผ๋ก ์๊ฐ์ ํ์๋ int ํ์
์ผ๋ก ๋ณํ์ด ๊ฐ๋ฅํ ๊ฒ ๊ฐ๋ค ์ถ์๊ฒ๋ค์ ๋ณํ์ด ๊ฐ๋ฅํฉ๋๋ค. int(๋ถ๋ฆฌ์ธ)๋ ๊ฐ๋ฅํฉ๋๋ค. ๋ถ๋ฆฌ์ธ ํ์
์ ์ ์๋ก ๋ณํ ๊ฐ๋ฅํ๋๋ก ์๋ ์์ ๋ฅผ ๋ณด๋ฉด ํ์ด์ฌ ๋ด๋ถ์ ์ผ๋ก True ..
dictionary, ์ค์ฌ์ dict ์๋ฃํ์ ๋ฐ์ดํฐ๊ฐ์ ์ฐ๊ด์ฑ์ด ์๊ณ , ํ ๋ฐ์ดํฐ๋ก ๋ค๋ฅธ ๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฌ์ค๊ณ ์ถ์ ๋ ์ ์ฉํ๊ฒ ์ธ ์ ์์ต๋๋ค. dict๋ฅผ ๋ง๋๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ผ๋ก ๋ฆฌ์คํธ ๋ ๊ฐ๋ฅผ ์ง์ง๋ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค. # ๋ ๊ฐ์ ๋ฆฌ์คํธ๋ฅผ ๊ฐ๊ฐ key, value๋ก ํ์ฌ dict๋ฅผ ์์ฑ dessert = ['์ฟ ํค', '๋ง๋ค๋ ', '๋ง์นด๋กฑ', '์ผ์ดํฌ'] num = [1,2,3,4] ์ ๋ ์ผ์ดํฌ์ ๋นต์ ์ข์ํ๊ธฐ ๋๋ฌธ์ ๋์ ํธ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด ๋ดค์ต๋๋ค. ์๋์ ์ซ์ ๋ฆฌ์คํธ์ ๋์ ํธ ๋ฆฌ์คํธ๋ฅผ dict๋ก ๋ง๋ค์ด ๋ณด๊ฒ ์ต๋๋ค. ์ ๋ ๋์ ํธ๋ฅผ key๊ฐ์ผ๋ก, ์ซ์๋ฅผ value๋ก ๋๊ณ ์ถ์ต๋๋ค. zip์ ์ฌ์ฉํ๋ฉด ์์ฝ๊ฒ dict๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค. # code 1 dessert_dic1 = { name: val..
ํ์ด์ฌ์์ 2์ฐจ์ ๋ฐฐ์ด์ ์
๋ ฅ๋ฐ๋ ๋ฐฉ๋ฒ์ 3๊ฐ์ง๊ฐ ์์ต๋๋ค. ์๋์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด, ๊ฐ๋ก A, ์ธ๋ก B ๊ธธ์ด์ ๋ฐฐ์ด์ ์ ์ธํ๋ค๊ณ ๊ฐ์ ํด ๋ด
์๋ค! ์ฐธ๊ณ ๋ก, 3๊ฐ์ง ๊ฒฝ์ฐ๋ ๋ชจ๋ ๋ฐฐ์ด์ ์ธ๋ก(B) ์ ํฌ๊ธฐ๋ฅผ ์๋ ๊ฒฝ์ฐ์๋ง ์ฌ์ฉํ ์ ์์ต๋๋ค. 1. ์์ ํ๋์ฉ ์
๋ ฅ๋ฐ๊ธฐ arr = [0]*B // 2์ฐจ์ ๋ฐฐ์ด์ ๊ฐ๋ก๊ธธ์ด : B for i in range(B): arr[i] = list(map(int, input().split())) input, split, map, list ์ ๋ํ ์ดํด๊ฐ ์ ๋์ง ์๋๋ค๋ฉด [Python] 1์ฐจ์ ๋ฐฐ์ด ์
๋ ฅ๋ฐ๊ธฐ๋ฅผ ์ฐธ๊ณ ํด์ฃผ์ธ์ 2. ์์์ list ์ถ๊ฐํ๊ธฐ arr = [] for i in range(B): arr.append(list(map(int, input().split()))..
1. ๋์ด์ฐ๊ธฐ ๊ฐ๊ฒฉ์ผ๋ก ๋ค์ด์ฌ ๋ ์
๋ ฅ์ด ์๋์ ๊ฐ๋ค๋ฉด, ํ ์ค์ ํ๋ฒ์ ์
๋ ฅ๋ฐ์ ๋ฐฐ์ด๋ก ๋ง๋๋ ๋ฐฉ์์ ์ฌ์ฉํ ์ ์์ต๋๋ค. 1 2 3 4 5 arr = list(map(int, input().split())) ์ฝ๋์ ๋ํ ์์ธ ์ค๋ช
์ ์๋์ ๊ฐ์ต๋๋ค. input() : ํค๋ณด๋๋ฅผ ํตํด ๋ฌธ์์ด์ ์
๋ ฅ๋ฐ๋๋ค (enter ์
๋ ฅ์ ๊น์ง๋ฅผ ํ์ค๋ก ํ๋จ) split() : ๋ฌธ์์ด์ ๋์ด์ฐ๊ธฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ๋๋๋ค map(int, ๋ฆฌ์คํธA) : ๋ฆฌ์คํธA ์ ๋ชจ๋ ์์๋ฅผ int ๋ก ๋ณํ list() : map ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐฐ์ด๋ก ๋ฐํ 2. Enter ๊ฐ๊ฒฉ์ผ๋ก ๋ค์ด์ฌ ๋ ์ด ๊ฒฝ์ฐ๋ ์
๋ ฅ๋๋ ์ค์ ์๋ฅผ ์๋ ๊ฒฝ์ฐ์๋ง ์ฌ์ฉํ ์ ์์ต๋๋ค. ์
๋ ฅ๋ฐฉ์์ด ์๋์ ๊ฐ๋ค๋ฉด, ํ๋์ฉ ์์๋ฅผ ์ ์๋ก ๋ณํํ์ฌ ๋ฐฐ์ด์ append ..
๋ฌธ์์ด(string) ๋ฌธ์์ด์ ํ๋ก๊ทธ๋๋ฐ์์ ๊ฐ์ฅ ์์ฃผ์ฐ์ด๋ ๋ฐ์ดํฐ ํ์์ด๋ค. ๋ฌธ์์ด์ ๋ฌธ์๋ค์ ์ํ์ค๋ก ์ ์๋๋ค. ๊ธ์๋ค์ด ์ค(string)๋ก ๋ฌถ์ฌ ์๋ ๊ฒ์ด ๋ฌธ์์ด์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค. ํ์ด์ฌ์์๋ str ํด๋์ค๊ฐ ๋ฌธ์์ด์ ๋ํ๋ธ๋ค. str ํด๋์ค๋ ํ์ด์ฌ์ ๋ด์ฅ ํด๋์ค์ด๋ค. ํ์ด์ฌ์์ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์์ ๋ฐ์ดํ๋ ํฐ ๋ฐ์ดํ๋ก ๊ฐ์ธ์ ํํํ๋ค. ๋ฌธ์์ด์ str ํด๋์ค์ ์์ฑ์๋ฅผ ํธ์ถํ์ฌ์ ์์ฑํ ์๋ ์๊ณ ์๋๋ฉด ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์ด์ฉํ์ฌ ์์ฑํ์ฌ๋ ๋๋ค. s1 = str("Hello") # ์์ฑ์ ์ด์ฉ s2 = "Hello“ # ๋ฆฌํฐ๋ด ์์ฑ ๋ฌธ์์ด์ ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅํ ๊ฐ์ฒด์ด๋ค. ๋ฌธ์์ด ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ฉด ๋ ์ด์ ๋ณ๊ฒฝ๋ ์ ์๋ค. ๋ฌธ์์ด์ ๋ณ๊ฒฝ๋ ์ ์๊ธฐ์, ๋ณ๊ฒฝ๋ ๋ฌธ์์ด์ด ํ์ํ๋ฉด ์๋ก์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ฒ..
enumerateํจ์ 1) ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ ๋ ๋ฆฌ์คํธ์ ์์๊ฐ, ์ฆ ์ธ๋ฑ์ค์ ์ ๋ณด๊ฐ ํ์ํ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค. enumerateํจ์๋ ๋ฆฌ์คํธ์ ์์์ ์์๊ฐ์ ๋ถ์ฌํด์ฃผ๋ ํจ์์
๋๋ค. ์ฌ์ฉ ์์ ๋ ์๋์ ๊ฐ์ต๋๋ค. >>> item = ["First", "Second", "Third"] >>> data = enumerate(item) >>> print(data, type(data)) 2) enumerateํจ์๋ ์
๋ ฅ์ผ๋ก ๋ฐ์ ๋ฐ์ดํฐ์ ์ธ๋ฑ์ค ๊ฐ์ ํฌํจํ๋ enumerate ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํด์ค๋๋ค. >>> item = ["First", "Second", "Third"] >>> for val in enumerate(item): ... print(val) (0, 'First') (1, 'Second') (2, 'Thir..
โ๏ธ๋์
๋๋ฆฌ์ ๊ฐ๋
๋์
๋๋ฆฌ(dictionary)๋ ์ฌ์ ์ด๋ผ๋ ์๋ฏธ๋ค. ์ฌ์ ์๋ ๋จ์ด์ ๊ทธ ๋จ์ด์ ์ค๋ช
์ด ์ ์ฅ๋์ด ์๋ค. ์ฌ๊ธฐ์ ๋จ์ด๋ ํค(key), ์ค๋ช
์ ๊ฐ(value)์ด๋ค. ํ์ด์ฌ์ ๋์
๋๋ฆฌ๋ ํค์ ๊ฐ์ ์์ ์ ์ฅํ ์ ์๋ ๊ฐ์ฒด์ด๋ค. ๊ทธ๋ฆฌ๊ณ ํค๋ฅผ ์ด์ฉํ์ฌ ๊ฐ์ ๊ฒ์ํ ์ ์๋ค. ๋์
๋๋ฆฌ์์ ํค๋ ํด์๊ฐ๋ฅ ๊ฐ์ฒด์ด์ด์ผ ํ๊ณ ์ค๋ณต๋๋ ๊ฐ์ ํ์ฉํ์ง ์๋๋ค. โ๏ธ๋์
๋๋ฆฌ์ ์์ฑ ๋์
๋๋ฆฌ๋ ์ค๊ดํธ ์์ ํญ๋ชฉ์ ์ผํ๋ก ๋ถ๋ฆฌ์์ผ์ ๋์ดํ๋ฉด ๋๋ค. ํญ๋ชฉ์ ํค(key)์ ๊ฐ(value)์ผ๋ก ๊ตฌ์ฑ๋๋ค. ๋์
๋๋ฆฌ์์ ๊ฐ์ ์ด๋ค ๊ฐ์ฒด์ด๋ ์ง ๊ฐ๋ฅํ์ง๋ง ํค๋ ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅํ ๊ฐ์ฒด์ด์ด์ผ ํ๋ค. ์ฆ ๋ฌธ์์ด์ด๋ ์ซ์์ฌ์ผ ํ๋ค. ๋ง์ฝ ํค๊ฐ ๋ณ๊ฒฝ์ด ๊ฐ๋ฅํ๋ฉด ๋ง์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๊ธฐ ๋๋ฌธ์ด๋ค. ์๋ฅผ ๋ค์ด ๋ค์ด๋ฒ๋ , ๋ฅ์จ ๊ฒ์์ด๋ ์์ด๋(..
๋๊ฐ์ ๋ฌธ์์ด์ ๋น๊ตํ๋ ๋ฐฉ๋ฒ์ ๋ณด๊ฒ ์ต๋๋ค. ๋น๊ต ๋ฐฉ๋ฒ์ผ๋ก๋ ์์ ์ผ์น, ๋ถ๋ถ ์ผ์น๊ฐ ์์ต๋๋ค. ใป ์์ ์ผ์น : == , != ใป ๋ถ๋ถ ์ผ์น : in , not in ใป ์ ๋ฐฉ ์ผ์น : startswith() ใป ํ๋ฐฉ ์ผ์น : endswith() ์์ค๋ก ์์ ๋ฅผ ๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค. ์์ ์ผ์น : == , != 2๊ฐ์ ๋ฌธ์์ด์ด ์์ ํ ์ผ์นํ๋์ง ํ์ ํ๊ธฐ ์ํด ์ฐ์ฐ์๋ก ==๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ผ์นํ๋ฉด True๋ฅผ ์ผ์นํ์ง ์์ผ๋ฉด False๋ฅผ ๋ฐํํฉ๋๋ค. print('abc' == 'abc') # True print('abc' == 'xyz') # False ๋๋ฌธ์์ ์๋ฌธ์๋ ์๋ณํ๋ ์ฃผ์ํด์ผ ํฉ๋๋ค. print('abc' == 'ABC') # False != ๋ 2๊ฐ์ ๋ฌธ์์ด์ด ์์ ํ ์ผ์นํ์ง ์์ผ๋ฉด True ์์ ..