๋ฌธ์์ด ๊ณ์ฐํ๊ธฐ ๐ข
Q. `my_string`์ "3 + 5"์ฒ๋ผ ๋ฌธ์์ด๋ก ๋ ์์์ ๋๋ค. ๋ฌธ์์ด `my_string`์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์์์ ๊ณ์ฐํ ๊ฐ์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ์ฐ์ฐ์๋ +, -๋ง ์กด์ฌํฉ๋๋ค.
- ๋ฌธ์์ด์ ์์๊ณผ ๋์๋ ๊ณต๋ฐฑ์ด ์์ต๋๋ค.
- 0์ผ๋ก ์์ํ๋ ์ซ์๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ์๋ชป๋ ์์์ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- 5 ≤ `my_string`์ ๊ธธ์ด ≤ 100
- `my_string`์ ๊ณ์ฐํ ๊ฒฐ๊ณผ๊ฐ์ 1 ์ด์ 100,000 ์ดํ์
๋๋ค.
- `my_string`์ ์ค๊ฐ ๊ณ์ฐ ๊ฐ์ -100,000 ์ด์ 100,000 ์ดํ์ ๋๋ค.
- ๊ณ์ฐ์ ์ฌ์ฉํ๋ ์ซ์๋ 1 ์ด์ 20,000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- `my_string`์๋ ์ฐ์ฐ์๊ฐ ์ ์ด๋ ํ๋ ํฌํจ๋์ด ์์ต๋๋ค.
- return type ์ ์ ์ํ์ ๋๋ค.
- `my_string`์ ์ซ์์ ์ฐ์ฐ์๋ ๊ณต๋ฐฑ ํ๋๋ก ๊ตฌ๋ถ๋์ด ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
my_string | result |
"3 + 4" | 7 |
A.
def solution(my_string):
return eval(my_string)
q. eval() ์ด๋?
`eval()` ํจ์๋ ๋ฌธ์์ด ํํ๋ก ์์ฑ๋ Python ํํ์์ ์คํํ๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ํจ์์ ๋๋ค.
์ฝ๋ ๋์ ์ผ๋ก ์คํํ ๋ ์ฌ์ฉ๋๋ฉฐ, ๊ฐ๋ ฅํ์ง๋ง ์ฃผ์ํด์ ์ฌ์ฉํด์ผ ํ๋ ํจ์์ ๋๋ค.
1. ๊ธฐ๋ณธ ๋์
๋ฌธ๋ฒ
eval(expression, globals=None, locals=None)
- expression: ์คํํ Python ํํ์์ ๋ฌธ์์ด๋ก ์ ๋ฌ
- globals (์ ํ์ ): ์ ์ญ ๋ณ์๋ฅผ ์ ์ํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋์ ๋๋ฆฌ (๊ธฐ๋ณธ๊ฐ: None)
- locals (์ ํ์ ): ์ง์ญ ๋ณ์๋ฅผ ์ ์ํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋์ ๋๋ฆฌ (๊ธฐ๋ณธ๊ฐ: None)
- ๋ฐํ๊ฐ: ํํ์์ ์คํ ๊ฒฐ๊ณผ
2. ์ฌ์ฉ ์์
1) ์ํ ํํ์ ํ๊ฐ
result = eval("3 + 5 * 2")
print(result) # ์ถ๋ ฅ: 13
2) ๋ณ์ ์ฌ์ฉ
x = 10
y = 5
result = eval("x * y + 2")
print(result) # ์ถ๋ ฅ: 52
3) ํจ์ ํธ์ถ
def greet(name):
return f"Hello, {name}!"
result = eval("greet('Alice')")
print(result) # ์ถ๋ ฅ: Hello, Alice!
3. ์ฃผ์ ๋งค๊ฐ๋ณ์
1) `globals`์ `locals`
`eval()`์ `globals`์ `locals`๋ฅผ ์ฌ์ฉํ๋ฉด ์ ์ญ ๋ฐ ์ง์ญ ๋ณ์๋ฅผ ์ ์ดํ ์ ์์ต๋๋ค.
globals_dict = {"x": 10, "y": 20}
locals_dict = {"z": 5}
result = eval("x + y + z", globals_dict, locals_dict)
print(result) # ์ถ๋ ฅ: 35
4. `eval()`์ ์ฅ์
- ๋์ ์ฝ๋ ์คํ:
- ๋ฐํ์์ Python ์ฝ๋๋ฅผ ๋์ ์ผ๋ก ํ๊ฐ ๊ฐ๋ฅ
- ํธ๋ฆฌํ ๊ณ์ฐ:
- ๋ฌธ์์ด๋ก ์ฃผ์ด์ง ์์์ด๋ ํํ์์ ํ๊ฐํ ๋ ์ ์ฉํจ
5. eval()์ ์ํ์ฑ๊ณผ ์ฃผ์์ฌํญ
`eval()`์ ์ธ๋ถ ์ ๋ ฅ์ ์คํํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ณด์ ์ํ์ด ๋ฐ๋ฆ ๋๋ค. ์ ์์ ์ธ ์ฝ๋๊ฐ ํฌํจ๋ ๋ฌธ์์ด์ ์คํํ๋ฉด ์ฌ๊ฐํ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
1) ์ ์ฑ ์ฝ๋์ ์ํ
# ์ํํ ์ฝ๋ ์์
user_input = "__import__('os').system('rm -rf /')"
eval(user_input) # ํ์ผ ์์คํ
์ญ์ ์ ๊ฐ์ ์ํํ ๋ช
๋ น์ด ์คํ ๊ฐ๋ฅ
2) ์์ ํ ๋์
- `literal_eval` (Python ast ๋ชจ๋):
- ๋จ์ ํํ์ ํ๊ฐ ์ `eval()` ๋์ ์์ ํ `literal_eval`์ ์ฌ์ฉํ ์ ์์
- `literal_eval`์ ๋ฆฌํฐ๋ด ๊ตฌ์กฐ(์ซ์, ๋ฌธ์์ด, ๋ฆฌ์คํธ ๋ฑ)๋ง ํ๊ฐ ๊ฐ๋ฅ
from ast import literal_eval
result = literal_eval("[1, 2, 3]") # ์์
print(result) # ์ถ๋ ฅ: [1, 2, 3]
6. `eval()`์ `exec()`์ ์ฐจ์ด์
๊ธฐ๋ฅ | `eval()` | `exec()` |
๋ชฉ์ | ํํ์ ํ๊ฐ (๊ฒฐ๊ณผ ๋ฐํ) | ๋ช ๋ น๋ฌธ ์คํ (๊ฒฐ๊ณผ ๋ฐํ ์์) |
์ฌ์ฉ ๋ฐฉ์ | `eval("3 + 5")` -> ๊ฒฐ๊ณผ ๋ฐํ | `exec("x = 5; print(x)")` -> ๊ฒฐ๊ณผ ์คํ |
๊ฒฐ๊ณผ | ํ๊ฐ๋ ํํ์์ ๊ฒฐ๊ณผ ๋ฐํ | Python ๋ช ๋ น๋ฌธ ์คํ (๋ฐํ๊ฐ ์์) |
์์ :
# eval()
result = eval("3 + 5")
print(result) # ์ถ๋ ฅ: 8
# exec()
exec("x = 10; print(x)") # ์ถ๋ ฅ: 10
7. ์์ฝ
- `eval()`: ๋ฌธ์์ด๋ก ์์ฑ๋ Python ํํ์์ ํ๊ฐํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ
- ์ฅ์ : ๋์ ์ฝ๋ ์คํ ๋ฐ ๊ฐ๋จํ ๊ณ์ฐ์ ์ ์ฉ
- ์ฃผ์: ์ธ๋ถ ์ ๋ ฅ ์ฒ๋ฆฌ ์ ๋ณด์์ ์ฃผ์ ํ์
- ๊ฐ๋ฅํ๋ฉด `literal_eval` ๊ฐ์ ์์ ํ ๋์์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์
ํ์ธ์ ๋ฌธ์ ํ์ด ๐ฅ
def solution(my_string):
return sum(int(i) for i in my_string.replace(' - ', ' + -').split(' + '))
์ฝ๋ ๋์ ์๋ฆฌ
- `my_string` ๋ฌธ์์ด ์์ `-` ์ฐ์ฐ์๋ฅผ `+-` ๋ก ๋ฌธ์๋ฅผ ๋์ฒดํ ํ, `+` ๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ์ชผ๊ฐ์ค
- ๋์ฒดํ `my_string` ์ผ๋ก `for` ๋ฃจํ๋ฅผ ๋๋ ค, ์ ์๋ก ํ๋ณํ ํ `i` ์ `sum` ๊ฐ์ ๋ฐํํ๋ค
- ์: ๋ฌธ์์ด์ด '5 - 8' ์ผ ๊ฒฝ์ฐ
- '5 + - 8' ๋ก ๊ต์ฒดํ ํ
- '5 + - 8' ์ sum ๊ฐ์ ๋ฐํ
- # ๊ฒฐ๊ณผ -3 ์ถ๋ ฅ
๋๋ ์ :
`eval()` ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธด ํ์ง๋ง
๋ณด์์ด ์ทจ์ฝํ๋ฏ๋ก ์ฃ๋ถ๋ฆฌ ์ฌ์ฉํ์ง ๋ง ๊ฒ~!
๊ทธ๋ฆฌ๊ณ `eval()` ๋ณด๋ค `replace()` ๋ฅผ ์ฌ์ฉํ ์ฝ๋๊ฐ
๋ ์ ๋ฐํด๋ณด์ ^__^
'Algorithm ๐ > ๋ฌธ์ ํ์ด ๐ฏ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[250123] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ ๋ฌธ ๋ฌธ์ (1) | 2025.01.23 |
---|---|
[250117] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ ๋ฌธ ๋ฌธ์ (2) | 2025.01.17 |
[250113] ํ๋ก๊ทธ๋๋จธ์ค ๊ธฐ์ด ํธ๋ ์ด๋ ๋ฌธ์ (0) | 2025.01.13 |
[250108] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ ๋ฌธ ๋ฌธ์ (0) | 2025.01.08 |
[250106] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ ๋ฌธ ๋ฌธ์ (1) | 2025.01.06 |