๐ก ๋ณธ ํฌ์คํ ์ ์์ ๋ด์ฉ, ๊ต์ฌ, ChatGPT๋ฅผ ์ฐธ๊ณ ํ์ฌ ์ ๋ฆฌํ ํ์ต ๊ธฐ๋ก์ ๋๋ค.
๊ธ๊ณผ ๊ทธ๋ฆผ ๋ฑ ๋ชจ๋ ์ฝํ ์ธ ์ ์ ๋ฆฌ ๋ฐ ์์ฑ์ ๋ณธ ๋ธ๋ก๊ทธ์์ ์ง์ ์ ์๋์์ต๋๋ค.
Python ๊ธฐ์ด๋ถํฐ Streamlit ๋ฐ์ดํฐ ์๊ฐํ๊น์ง ์ ๋ฆฌํ๋ ํ์ต ๊ธฐ๋ก์ ๋๋ค.
์ด ๊ธ์ '3. [ํ์ด์ฌ] Python ์๋ฃํ' ์ ๋๋ค.
Python ์๋ฃํ์ด๋
์๋ฃํ(data type)์ '๊ฐ์ ์ข ๋ฅ์ ๊ทธ ๊ฐ์ ๋ํด ์ํํ ์ ์๋ ์ฐ์ฐ์ ๊ท์น'์ ์๋ฏธํ๋ค.
์๋ฅผ ๋ค์ด ๋ค์ ์ธ ๊ฐ์ ์๋ก ๋ค๋ฅธ ์๋ฃํ์ด๋ค.
10
10.0
"10"
๊ฒ๋ณด๊ธฐ์๋ ๋น์ทํ์ง๋ง Python์ ์ด๋ฅผ ๋ค์์ฒ๋ผ ๊ตฌ๋ถํ๋ค. ์๋ฃํ์ ํ์ธํ๋ ํจ์๋ type() ์ด๋ค.
print(type(10))
print(type(10.0))
print(type("10"))
๊ฒฐ๊ณผ
<class 'int'>
<class 'float'>
<class 'str'>
์๋ฃํ์ ์ดํดํด์ผํ๋ ์ด์ ๋ ๋ค์๊ณผ ๊ฐ๋ค.
- ์ด๋ค ์ฐ์ฐ์ด ๊ฐ๋ฅํ์ง ์ ์ ์๋ค
- ๋ฐ์ดํฐ ์ฒ๋ฆฌ ๊ณผ์ ์์ ์ค๋ฅ๋ฅผ ์ค์ผ ์ ์๋ค
- Python ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ์ดํดํ ์ ์๋ค
- mutable / immutable ๊ฐ๋ ๊ณผ ์ฐ๊ฒฐ๋๋ค
Python์ ํต์ฌ ์ฒ ํ: Everything is object
Python์์ ๋งค์ฐ ์ค์ํ ๊ฐ๋ ์ด ํ๋ ์๋ค.
Everything is object
์ฆ, Python์์๋ ๋ชจ๋ ๊ฐ์ด ๊ฐ์ฒด(object) ์ด๋ค.
์๋ฅผ ๋ค์ด ์ซ์๋ ๊ฐ์ฒด๋ค.
x = 10
print(type(x))
๊ฒฐ๊ณผ
<class 'str'>
๋ฆฌ์คํธ๋ ๊ฐ์ฒด๋ค.
numbers = [1, 2, 3]
print(type(numbers))
๊ฒฐ๊ณผ
<class 'list'>
Python์์ ๊ฐ์ฒด๋ ๋ค์ ํน์ง์ ๊ฐ์ง๋ค.
- ํ์ (type)
- ๊ฐ(value)
- ๋ฉ์๋(method)
๊ฐ์ฒด์ ๋ฉ์๋ ํ์ธํ๊ธฐ
Python์์๋ ๊ฐ์ฒด๊ฐ ์ด๋ค ๊ธฐ๋ฅ์ ๊ฐ์ง๊ณ ์๋์ง ์ง์ ํ์ธํ ์ ์๋ค.
โ๏ธ ๊ฐ์ฒด์ ๊ธฐ๋ฅ ํ์ธ
text = "Python"
print(dir(text))
์ด ์ฝ๋๋ ๋ฌธ์์ด ๊ฐ์ฒด๊ฐ ๊ฐ์ง ๋ฉ์๋๋ฅผ ๋ชจ๋ ๋ณด์ฌ์ค๋ค.
ํน์ ๋ฉ์๋์ ์ค๋ช ๋ ํ์ธํ ์ ์๋ค.
โ๏ธ ๋ฉ์๋ ๋์๋ง ํ์ธ
help(text.upper)
์ด ๋ฐฉ์์ ์๋ก์ด ์๋ฃํ์ ๋ฐฐ์ธ ๋ ๋งค์ฐ ์ ์ฉํ๋ค.
Python์ ๊ธฐ๋ณธ ์๋ฃํ
Python์ ๊ธฐ๋ณธ ์๋ฃํ์ ๋ค์๊ณผ ๊ฐ์ด ๋ถ๋ฅ๋๋ค.
| ์๋ฃํ | ์ค๋ช |
| int | ์ ์ |
| float | ์ค์ |
| bool | ์ฐธ(True)/๊ฑฐ์ง(False) |
| str | ๋ฌธ์์ด |
| NoneType | ๊ฐ์ด ์์ |
| list | ์์๊ฐ ์๋ ์ปฌ๋ ์ |
| tuple | ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅํ ์ํ์ค |
| set | ์ค๋ณต ์๋ ์งํฉ |
| dict | key-value ๊ตฌ์กฐ |
์ด๋ฒ ๊ธ์์๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์๋ฃํ์ ์ค์ฌ์ผ๋ก ์ดํด๋ณธ๋ค.
์ซ์ํ (int, float)
์ ์์ ์ค์๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์ซ์ ์๋ฃํ์ด๋ค.
โ๏ธ ์ซ์ ์๋ฃํ ์์
a = 10
b = 3.14
print(type(a))
print(type(b))
์ซ์ ์๋ฃํ์ ๋ค์ํ ์ฐ์ ์ฐ์ฐ์ ์ง์ํ๋ค.
โ๏ธ ์ฐ์ ์ฐ์ฐ ์์
a = 10
b = 5
print(a > b)
print(a == b) # ๊ฐ์ผ๋ฉด True ๋ฐํ, ๋ค๋ฅด๋ฉด False ๋ฐํ
print(a != b) # ๋ค๋ฅด๋ฉด True ๋ฐํ, ๊ฐ์ผ๋ฉด False ๋ฐํ
print(a < b)
Boolean ๊ฐ์ ์กฐ๊ฑด๋ฌธ์์ ์ฌ์ฉ๋๋ค.
๋ฌธ์์ด (str)
๋ฌธ์์ด์ ํ ์คํธ ๋ฐ์ดํฐ๋ฅผ ํํํ๋ ์๋ฃํ์ด๋ค.
๋ฌธ์์ด์ 'immutable(๋ถ๋ณ) ๊ฐ์ฒด'์ด๊ธฐ ๋๋ฌธ์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด๋ ์๋ณธ ๋ฌธ์์ด์ด ์ง์ ์์ ๋์ง๋ ์๋๋ค.
๐ก ๋ฌธ์์ด immutable ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ ์ดํดํ๊ธฐ
a = "hello"
b = a
a = a + " world"
print(a)
print(b)
์คํ ๊ฒฐ๊ณผ
hello world
hello
๊ฒฐ๋ก ์ ์ ๋ฆฌํ๋ฉด,
๋ฌธ์์ด์ immutable ๊ฐ์ฒด์ด๊ธฐ ๋๋ฌธ์ ๋ฌธ์์ด ์ฐ์ฐ์ด ๋ฐ์ํ๋ฉด ๊ธฐ์กด ๋ฌธ์์ด์ ์์ ํ์ง ์๊ณ ์๋ก์ด ๋ฌธ์์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค.
๋ฐ๋ผ์ ๋ณ์ a๋ ์๋ก์ด ๋ฌธ์์ด ๊ฐ์ฒด "hello world"๋ฅผ ์ฐธ์กฐํ๊ฒ ๋๊ณ , ๊ธฐ์กด ๋ฌธ์์ด "hello"๋ ๋ณ์ b๋ง ์ฐธ์กฐํ๊ฒ ๋๋ค.
โญ๏ธ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ ๊ทธ๋ฆผ์ผ๋ก ์ดํดํ๊ธฐ
- a : ์ฃผํฉ์ ํ์ดํ ("hello world" ๊ฐ๋ฆฌํด)
- b : ํ๋์ ํ์ดํ ("hello" ๊ฐ๋ฆฌํด)

โญ๏ธโญ๏ธ ๊ฐ์ฒด ์ฃผ์ ํ์ธ
print(id(a))
print(id(b))
์๋ก ๋ค๋ฅธ ๊ฐ์ด ์ถ๋ ฅ ๋๋ค. ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ณ ์๋ค๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
โ๏ธ ๋ฌธ์์ด ์์ฑ ์์
name = "Python"
message = "Hello"
print(name)
print(message)
โ๏ธ ๋ฌธ์์ด ์ด์ด ๋ถ์ด๊ธฐ(Concatenation) ์์
๋ฌธ์์ด์ + ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ๋ฌ ๋ฌธ์์ด์ ํ๋๋ก ์ด์ด ๋ถ์ผ ์ ์๋ค.
first_name = "์ "
last_name = "๊ด์"
full_name = first_name + last_name
print(full_name)
์คํ ๊ฒฐ๊ณผ
์ ๊ด์
โ๏ธ ๊ณต๋ฐฑ์ ํฌํจํ์ฌ ๋ฌธ์์ด ์ฐ๊ฒฐํ๊ธฐ
first_name = "Python"
last_name = "Study"
title = first_name + " " + last_name
print(title)
์คํ ๊ฒฐ๊ณผ
Python Study
โ๏ธ์ฌ๋ฌ ๋ฌธ์์ด์ ํ ๋ฒ์ ์ฐ๊ฒฐํ๊ธฐ
language = "Python"
version = "3.12"
message = "ํ์ฌ ์ฌ์ฉ ์ค์ธ ์ธ์ด๋ " + language + "์ด๊ณ ๋ฒ์ ์ " + version + "์
๋๋ค."
print(message)
์คํ ๊ฒฐ๊ณผ
ํ์ฌ ์ฌ์ฉ ์ค์ธ ์ธ์ด๋ Python์ด๊ณ ๋ฒ์ ์ 3.12์
๋๋ค.
๋ฌธ์์ด ๋ฐ๋ณต (Repetition)
๋ฌธ์์ด์ * ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ ๋ฌธ์์ด์ ์ฌ๋ฌ ๋ฒ ๋ฐ๋ณตํ ์ ์๋ค.
โ๏ธ ๋ฌธ์์ด ๋ฐ๋ณต ์์
symbol = "*"
line = symbol * 10
print(line)
์คํ ๊ฒฐ๊ณผ
**********
โ๏ธ ๋ฌธ์์ด ํจํด ๋ฐ๋ณตํ๊ธฐ
pattern = "abc"
result = pattern * 3
print(result)
์คํ ๊ฒฐ๊ณผ
abcabcabc
โ๏ธ ๋ฐ๋ณต์ ํ์ฉํ ๊ฐ๋จํ ์ถ๋ ฅ ์์
title = "I like Python."
print("=" * 20)
print(title)
print("=" * 20)
์คํ ๊ฒฐ๊ณผ
====================
I like Python.
====================
๐ก ๋ฌธ์์ด ์ด์ด ๋ถ์ด๊ธฐ๋ ์ค์ ์ฝ๋์์ ๋ณดํต f-string ๋ฌธ์์ด ํฌ๋งท ๋ฐฉ์์ผ๋ก ๋ง์ด ์์ฑํฉ๋๋ค.
name = "ํ๊ธธ๋"
age = 20
message = f"์ด๋ฆ์ {name}์ด๊ณ ๋์ด๋ {age}์
๋๋ค."
print(message)
์คํ ๊ฒฐ๊ณผ
์ด๋ฆ์ ํ๊ธธ๋์ด๊ณ ๋์ด๋ 20์
๋๋ค.
๋ฉ์๋๋ก ๋ฌธ์์ด ๋ถ๋ฆฌํ๊ธฐ: .split()
split() ๋ฉ์๋๋ ๋ฌธ์์ด์ ํน์ ๊ธฐ์ค์ผ๋ก ๋๋์ด '๋ฆฌ์คํธ๋ก ๋ณํ' ํ๋ค.
โ๏ธ ๋ฌธ์์ด ๋ถ๋ฆฌ ์์
sentence = "Python is a powerful programming language"
words = sentence.split()
print(words)
์คํ ๊ฒฐ๊ณผ
['Python', 'is', 'a', 'powerful', 'programming', 'language']
๊ธฐ๋ณธ์ ์ผ๋ก ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ๋ถ๋ฆฌํ๋ค. ๊ตฌ๋ถ์๋ฅผ ์ง์ ํ ์๋ ์๋ค.
โ๏ธ ๊ตฌ๋ถ์ ๊ธฐ์ค ๋ถ๋ฆฌ
data = "apple,banana,grape,orange"
fruits = data.split(",")
print(fruits)
์คํ ๊ฒฐ๊ณผ
['apple', 'banana', 'grape', 'orange']
์ด ๋ฐฉ์์ CSV ๋ฐ์ดํฐ ์ฒ๋ฆฌ์์๋ ์์ฃผ ์ฌ์ฉ๋ฉ๋๋ค.
๋ฉ์๋๋ก ๋ฌธ์์ด ๊ฒฐํฉํ๊ธฐ: .join()
join() ๋ฉ์๋๋ ๋ฆฌ์คํธ์ ์๋ ๋ฌธ์์ด์ 'ํ๋์ ๋ฌธ์์ด๋ก ๊ฒฐํฉ'ํ๋ค.
โ๏ธ join ์์
words = ["Python", "Data", "Analysis"]
sentence = " ".join(words)
print(sentence)
์คํ ๊ฒฐ๊ณผ
Python Data Analysis
๋ค๋ฅธ ๊ตฌ๋ถ์๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
โ๏ธ ๋ค๋ฅธ ๊ตฌ๋ถ์๋ก ๋ฌธ์์ด ์ฐ๊ฒฐ
fruits = ["apple", "banana", "orange"]
result = ", ".join(fruits)
print(result)
์คํ ๊ฒฐ๊ณผ
apple, banana, orange
๋ฉ์๋๋ก ๋ฌธ์์ด ๊ณต๋ฐฑ ์ ๊ฑฐ: .strip()
์ฌ์ฉ์ ์ ๋ ฅ์ด๋ ๋ฐ์ดํฐ ํ์ผ์ ์ฒ๋ฆฌํ ๋ ๋ฌธ์์ด ์๋ค์ '๋ถํ์ํ ๊ณต๋ฐฑ'์ด ํฌํจ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
์ด๋ด ๋ strip() ๋ฉ์๋๋ ๋ฌธ์์ด์ ์๋ค ๊ณต๋ฐฑ์ ์ ๊ฑฐํ๋ค.
โ๏ธ ๊ณต๋ฐฑ ์ ๊ฑฐ ์์
text = " Hello Python "
clean_text = text.strip()
print(clean_text)
์คํ ๊ฒฐ๊ณผ
Hello Python
์ผ์ชฝ ๋๋ ์ค๋ฅธ์ชฝ ๊ณต๋ฐฑ๋ง ์ ๊ฑฐํ ์๋ ์์ต๋๋ค.
โ๏ธ lstrip / rstrip
text = " Python "
print(text.lstrip())
print(text.rstrip())
์คํ ๊ฒฐ๊ณผ
Python
Python
๋ฉ์๋๋ก ๋ฌธ์์ด ์นํ: .replace()
replace() ๋ฉ์๋๋ ๋ฌธ์์ด์ ํน์ ๋ถ๋ถ์ ๋ค๋ฅธ ๋ฌธ์์ด๋ก ๋ณ๊ฒฝํ๋ค.
โ๏ธ ๋ฌธ์์ด ์นํ ์์
text = "I like Java"
new_text = text.replace("Java", "Python")
print(new_text)
์คํ ๊ฒฐ๊ณผ
I like Python
์ฌ๋ฌ ๋ฒ ๋ฑ์ฅํ๋ ๋ฌธ์์ด๋ ๋ชจ๋ ๋ฐ๋๋ค.
โ๏ธ ์ฌ๋ฌ ๋ฌธ์์ด ์นํ
text = "apple apple apple"
result = text.replace("apple", "orange")
print(result)
์คํ ๊ฒฐ๊ณผ
orange orange orange
๋ฌธ์์ด ์ฒ๋ฆฌ ์์ (์ข ํฉ)
์์์ ๋ฐฐ์ด ๋ฉ์๋๋ค์ ํจ๊ป ์ฌ์ฉํ๋ ์์ ์ด๋ค.
โ๏ธ ์ฌ์ฉ์ ์ ๋ ฅ ๋ฌธ์์ด ์ ๋ฆฌ
raw_data = " python, java, c++, python , java "
clean_data = raw_data.strip()
languages = clean_data.split(",")
languages = [lang.strip().upper() for lang in languages]
unique_languages = sorted(set(languages))
result = ", ".join(unique_languages)
print(result)
์คํ ๊ฒฐ๊ณผ
C++, JAVA, PYTHON
์ด ์์ ์์๋ ๋ค์ ๊ฐ๋ ๋ค์ด ํจ๊ป ์ฌ์ฉ๋์๋ค.
strip() → ๊ณต๋ฐฑ ์ ๊ฑฐ
upper() → ๋ชจ๋ ๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก ๋ณ๊ฒฝ
split() → ๋ฌธ์์ด ๋ถ๋ฆฌ
list comprehension → ๋ฐ์ดํฐ ์ ๋ฆฌ
set() → ์ค๋ณต ์ ๊ฑฐ
sorted() → ์ ๋ ฌ
join() → ๋ฌธ์์ด ๊ฒฐํฉ
์ด๋ฐ ๋ฐฉ์์ ์ค์ ๋ฐ์ดํฐ ์ฒ๋ฆฌ์์๋ ๋งค์ฐ ์์ฃผ ์ฌ์ฉ๋๋ค.
None ์๋ฃํ
None์ '๊ฐ์ด ์์์ ๋ํ๋ด๋ ํน๋ณํ ๊ฐ์ฒด'์ด๋ค.
โ๏ธ None ์์
value = None
print(value)
print(type(value))
None์ ์กฐ๊ฑด๋ฌธ์์ False์ฒ๋ผ ๋์ํ๋ค.
print(bool(None))
๋ฆฌ์คํธ (list)
๋ฆฌ์คํธ๋ Python์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ ์ปฌ๋ ์ ์๋ฃํ์ด๋ค.
โ๏ธ ๋ฆฌ์คํธ ์์ฑ
numbers = [1, 2, 3, 4, 5]
print(numbers)
print(type(numbers))
๋ฆฌ์คํธ๋ ๋ค์ ํน์ง์ ๊ฐ์ง๋ค.
- ์์ ์กด์ฌ
- ์ธ๋ฑ์ฑ ๊ฐ๋ฅ, ์ฌ๋ผ์ด์ฑ ๊ฐ๋ฅ
- ๋ณ๊ฒฝ ๊ฐ๋ฅ (mutable)
โ๏ธ ๋ฆฌ์คํธ ์ธ๋ฑ์ฑ
numbers = [10, 20, 30, 40]
print(numbers[0])
print(numbers[-1])
ํ๋ณํ (Type Casting)
Python์์๋ ์๋ฃํ์ ๋ณํํ ์ ์๋ค.
โ๏ธ ํ๋ณํ ์์
print(int("3"))
print(float("3.14"))
print(str(100))
์ปฌ๋ ์ ์๋ฃํ๋ ๋ณํํ ์ ์๋ค.
tp = (1, 2, 3)
lst = list(tp)
print(lst)
bool ํ๋ณํ ๊ท์น
Python์์๋ ๊ฐ์ด ์กด์ฌํ๋์ง ์ฌ๋ถ์ ๋ฐ๋ผ True / False ๊ฐ ๊ฒฐ์ ๋๋ค.
โ๏ธ bool ๋ณํ ์์
print(bool(100))
print(bool(""))
print(bool([]))
print(bool([1,2,3]))
print(bool(None))
์คํ ๊ฒฐ๊ณผ
True
False
False
True
False
์ผ๋ฐ์ ์ธ ๊ท์น
๊ฐ์ด ์์ → True
๊ฐ์ด ์์ → False
๋ฆฌ์คํธ์ ์ฐธ์กฐ ๊ณต์
๋ฆฌ์คํธ๋ mutable ๊ฐ์ฒด์ด๊ธฐ ๋๋ฌธ์ ์ฐธ์กฐ ๊ณต์ ๊ฐ ๋ ๋ช ํํ๊ฒ ๋๋ฌ๋๋ค.
โ๏ธ ๋ฆฌ์คํธ ์ฐธ์กฐ ์์
a = [10, 20]
b = a
b.append(30)
print(a)
print(b)
์ด ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ค.
a โโโ
โโโโบ [10, 20, 30]
b โโโ
๊ฐ์ ๋ฆฌ์คํธ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ณ ์๊ธฐ ๋๋ฌธ์, b์์ ์์ ํ๋ฉด a๋ ํจ๊ป ๋ณ๊ฒฝ๋๋ค.
์ด ๊ฐ๋ ์ ์ถํ ํฌ์คํ ํ ๊ธ์์ ๋ ๊น๊ฒ ๋ค๋ฃจ๊ฒ ๋๋ค.
10. [ํ์ด์ฌ] mutable vs immutable
11. Python ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ
๋ง๋ฌด๋ฆฌ
์ด๋ฒ ๊ธ์์๋ Python ์๋ฃํ์ ์ ์ฒด ๊ตฌ์กฐ๋ฅผ ์ดํด๋ณด์๋ค.
ํต์ฌ ๊ฐ๋ ์ ๋ค์๊ณผ ๊ฐ๋ค.
- Python์ ๋ชจ๋ ๊ฐ์ ๊ฐ์ฒด๋ค
- type()์ผ๋ก ์๋ฃํ์ ํ์ธํ ์ ์๋ค
- ๊ธฐ๋ณธ ์๋ฃํ: int, float, bool, str, None
- ์ปฌ๋ ์ ์๋ฃํ: list, tuple, set, dict
- ํ๋ณํ์ ํตํด ์๋ฃํ์ ๋ฐ๊ฟ ์ ์๋ค
- Python ๋ณ์๋ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ค (๊ฐ์ฒด ์ฃผ์๋ id()๋ฅผ ํตํด ํ์ธ ๊ฐ๋ฅ)
- mutable ๊ฐ์ฒด๋ ์ฐธ์กฐ ๊ณต์ ์ ์ํด ํจ๊ป ๋ณ๊ฒฝ๋ ์ ์๋ค
์ด ๊ฐ๋ ์ ์ดํดํ๋ฉด ๋ค์ ๊ธ์ธ '4. [ํ์ด์ฌ] ํํ๊ณผ ํจํน/์ธํจํน'์ ํจ์ฌ ์ฝ๊ฒ ์ดํดํ ์ ์๋ค.
'Python & SQL > Python Basics' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| 5. [ํ์ด์ฌ] ๋์ ๋๋ฆฌ (0) | 2026.03.06 |
|---|---|
| 4. [ํ์ด์ฌ] ํํ๊ณผ ํจํน/์ธํจํน (0) | 2026.03.06 |
| 2. [ํ์ด์ฌ] ์กฐ๊ฑด๋ฌธ๊ณผ ๋ฐ๋ณต๋ฌธ (0) | 2026.03.06 |
| 1. [ํ์ด์ฌ] Python ์์ํ๊ธฐ (0) | 2026.03.06 |
| [ํ์ด์ฌ ํ์ต] Python ์ ๋ฆฌ ์๋ฆฌ์ฆ (๊ธฐ์ด๋ถํฐ ๊ฐ์ฒด์งํฅ๊น์ง) (0) | 2026.03.06 |