Introduction to Python II (Python Basics)

by JunPyo Park

Part of the Alpha Square Lecture Series:

• blog.alphasquare.co.kr
• junpyopark.github.io

---

파이썬 기초와 자료구조, 문자열, 조건문, 반복문 그리고 함수에 대해서 간단하게 정리해 보았습니다. 주피터 노트북 환경에서 작성한 문서이기 때문에 주피터 노트북을 켜고 따라서 실습해 보시면 쉽게 이해하실수 있습니다.

문자열 처리하기

위에서 살펴 보았듯이 string 타입은 텍스트를 표현하는데 주로 사용됩니다. 여기서는 몇가지 내장함수들을 살펴보고 필요에 맞게 문자열을 다룰 수 있는 방법들을 알아보도록 하겠습니다.

first_string = 'I am '
second_string = 'a boy'
third_string = first_string + second_string
third_string

'I am a boy'

스트링 자료형 또한 인덱싱이 되어 있기 때문에(ordered) 리스트 슬라이싱 기법들을 똑같이 활용할 수 있습니다.

my_string = 'Supercalifragilisticexpialidocious'
print('The first letter is: ', my_string[0]) # 대문자 S
print ('The last letter is: ', my_string[-1]) # 소문자 s
print ('The second to last letter is: ', my_string[-2]) # 소문자 u
print ('The first five characters are: ', my_string[0:5]) # Super
print ('Reverse it!: ', my_string[::-1]) # 문자열 역순으로 출력

The first letter is:  S
The last letter is:  s
The second to last letter is:  u
The first five characters are:  Super
Reverse it!:  suoicodilaipxecitsiligarfilacrepuS

내장된 객체(built-in objects)들은 객체들과 연결된 특별한 함수들을 가질 수 있습니다. 이를 메서드(methods)라고 합니다. 마침표(.)를 사용하여 메서드에 접근할 수 있습니다. 나중에 다른 강좌에서 이에대해 자세히 다루도록 하겠습니다.

• count() 메서드을 활용하여 다음과 같이 특정 문자열이 몇 번 등장하는지 셀 수 있습니다.

print('Count of the letter i in Supercalifragilisticexpialidocious: ', 
      my_string.count('i'))
print('Count of "li" in the same word: ', 
      my_string.count('li'))

Count of the letter i in Supercalifragilisticexpialidocious:  7
Count of "li" in the same word:  3

• find() 메서드를 활용하여 특정 값이 제일 처음 나오는 곳의 위치(인덱스)를 찾을 수 있습니다.

print('The first time i appears is at index: ', my_string.find('i'))

The first time i appears is at index:  8

• replace() 메서드를 활용하여 문자열을 부분적으로 치환할 수 있습니다.

print("All i's are now a's: ", my_string.replace('i', 'a'))

All i's are now a's:  Supercalafragalastacexpaaladocaous

print("It's raining cats and dogs".replace('dogs', 'more cats'))

It's raining cats and more cats

• upper() 과 lower() 메서드를 활용하여 문자열을 대문자/소문자 로 변경 가능합니다.

my_string = "I can't hear you"
print(my_string.upper())
my_string = "I said HELLO"
print(my_string.lower())

I CAN'T HEAR YOU
i said hello

문자열 포맷팅(String Formatting)

format() 메서드를 사용하여 문자열을 포맷팅 할 수 있습니다.

my_string = "{0} {1}".format('Marco', 'Polo')
print(my_string)

Marco Polo

my_string = "{1} {0}".format('Marco', 'Polo')
print(my_string)

Polo Marco

중괄호({})를 사용하여 문자열이 채월질 곳임을 나타낼 수 있고 안에 들어가는 숫자를 통해 몇 번째로 채워지는 곳인지 표기가 가능합니다.

format()과 관련된 자세한 설명은 공식 Documentation 을 참고해 주세요.

포맷팅의 다른 방법으로는 다음과 같이 %를 사용하는 방법이 있습니다.

print('insert %s here' % 'value')

print('There are %s cats in my %s' % (13, 'apartment'))

There are 13 cats in my apartment

여기서 %s 는 파이썬 상에서 지정된 값을 문자열로 변환하여 처리하라는 의미 입니다. formatting documentation을 확인하여 추가적인 예제들과 기호들을 확인 할 수 있습니다.

논리 연산자(Logical Operators)

기초 논리(Basic Logic)

논리 연산자는 boolean 값들을 처리하는 연산자들을 의미합니다. bool타입은 참(True)과 거짓(False) 중 하나의 값(또는 $1$이나 $0$)만 가질 수 있습니다.

학창시절 '명제'란 참과 거짓을 구분할 수 있는 문장 이라고 배웠습니다. 파이썬에서도 이런 참과 거짓을 명확히 구분되는 구문(statement)을 == (같다), != (같지 않다), < (작다), > (크다), <= (작거나 같다), 그리고 >= (크거나 같다) 와 같은 기호를 통해 표현 할 수 있습니다.

print(5==5)

True

print(5>5)

False

이는 물론 변수에도 적용이 가능합니다.

m = 2
n = 23
print(m < n)

True

참이나 거짓 값을 갖는 값이 두개 있을 때, or,and,not과 같은 논리 연산자(logical operator)를 정의할 수 있습니다.

statement_1 = 10 > 2
statement_2 = 4 <= 6
print("Statement 1 truth value: {0}".format(statement_1))
print("Statement 2 truth value: {0}".format(statement_2))
print("Statement 1 and Statement 2: {0}".format(statement_1 and statement_2))

Statement 1 truth value: True
Statement 2 truth value: True
Statement 1 and Statement 2: True

or 연산자는 논리적 or 연산을 수행합니다. 두가지 statement 중 하나라도 참(True)값을 가지고 있다면 전체 구문도 True가 됩니다. and 연산자는 두 statement가 모두 True일 경우 에만 True값을 반환합니다. 그러지 않다면 False 값을 반환합니다. not 연산자는 뒤에 있는 statement의 진위값(True or False)를 거꾸로 출력하는 연산자 입니다. not뒤의 statement가 True라면 False를 False라면 True를 반환합니다.

P와 Q라는 두개의 logical statements를 가지고 있을 때 각각 경우에 대한 연산값은 다음 표와 같이 나오게 됩니다.

P	Q	not P	P and Q	P or Q
True	True	False	True	True
False	True	True	False	True
True	False	False	False	True
False	False	True	False	False

print(((2 < 3) and (3 > 0)) or ((5 > 6) and not (4 < 2)))

True

위의 결과가 출력되는 과정을 살펴보면 다음과 같습니다.

• (True and True) or (False and not False)
• True or (False and True)
• True or False
• True

진위값(Truthiness)

bool() 함수는 어떤 값을 참/거짓 형태로 바꾸어주는 함수 입니다. 그렇다면 어떤 경우에 참(True)이 나오고 어떤 경우에 거짓(False)이 나오게 될까요? 일반적으로 string, tuple, dictionaries, lists의 경우 내용물이 하나라도 들어있다면 참 값이 반환되고 비어 있다면 거짓 값이 반환됩니다.

bool('')

False

bool('I like Python!')

True

bool([])

False

bool([1,2,3])

True

bool(1)

True

bool(0)

False

bool(3.141592)

True

숫자의 경우 0이면 False, 그 이외에는 True 가 나옵니다.

If 구문

특정 조건을 만족할 때 어떤 코드를 실행시키고 싶다면 If 구문을 사용하여 이를 구현할 수 있습니다.

다음과 같은 코드에서 if문 안의 condition이 참 이라면 안에있는 코드가 실행됩니다. 만약 condition이 거짓이라면 if문 내부의 코드는 스킵되고 else 구문이 있는 곳으로 가서 나머지 코드가 실행되게 됩니다. 만약 else구문이 없다면 아무 일도 일어나지 않습니다. 이 때 condition은 위에서 배운 논리 연산자를 통해 표현되거나 진위값을 통해 설정 할 수 있습니다. if 구문은 콜론(:)과 indented text(4-스페이스 또는 tab)을 통해 정의 할 수 있습니다.

# if 구문의 기초적인 뼈대 입니다.
# 여기서 "Condition"은 공백이 아니기 때문에 항상 True 입니다. 
# 여기서는 if 문이 사용되는 형태를 익히시면 됩니다.
if "Condition": 
    # "Condition"은 공백이 아닌 문자열이기 때문에 True 값을 가지게 되고
    # 이 예제에서 이곳의 indent 되어진 코드는 항상 실행됩니다.
    print(True)
else:
    # 만약 condition이 거짓이라면 이곳의 코드가 처음 블록의 코드 대신 실행되게 됩니다.
    print(False)
# 이 예제에서 else에 있는 코드는 절대 실행되지 않습니다. 
# 왜냐하면 "Condition"의 진위값이 True 이기 때문입니다.

True

i = 4
if i == 5:
    print('The variable i has a value of 5')

위 예제를 살펴보면 i 값이 4이기 때문에 i==5 라는 명제(statement)는 거짓 값을 가지게 되고 아무런 문구도 출력이 되지 않습니다. 위에 코드에 else문을 추가함으로써 아래와 같이 실행되는 부분을 만들 수 있습니다.

i = 4
if i == 5:
    print("All lines in this indented block are part of this block")
    print('The variable i has a value of 5')
else:
    print("All lines in this indented block are part of this block")
    print('The variable i is not equal to 5')

All lines in this indented block are part of this block
The variable i is not equal to 5

if 문에서 조건이 거짓이라 빠져나왔을 때 또 다른 조건을 확인해 볼 수 있도록 elif 구문을 첨가할 수 있습니다. elif는 "else if"의 줄임말 입니다. 한개의 if 구문에 여러개의 elif구문들을 포함할 수 있습니다.

i = 3
if i == 1:
    print('The variable i has a value of 1')
elif i == 2:
    print('The variable i has a value of 2')
elif i == 3:
    print('The variable i has a value of 3')
else:
    print("I don't care what i is")

The variable i has a value of 3

if 구문을 다음과 같이 중첩하여 사용할 수 있습니다.

i = 10
if i % 2 == 0:
    if i % 3 == 0:
        print ('i is divisible by both 2 and 3! Wow!')
    elif i % 5 == 0:
        print ('i is divisible by both 2 and 5! Wow!')
    else:
        print ('i is divisible by 2, but not 3 or 5. Meh.')
else:
    print('I guess that i is an odd number. Boring.')

i is divisible by both 2 and 5! Wow!

위에서 공부한 논리 연산자(Logical Operator)를 사용하여 여러개의 조건을 묶어서 하나의 if문에 집어넣을 수 있습니다.

i = 5
j = 12
if i < 10 and j > 11:
    print('{0} is less than 10 and {1} is greater than 11!'.format(i, j))

5 is less than 10 and 12 is greater than 11!

문자열 변수에도 적용이 가능합니다.

my_string = "Carthago delenda est"
if my_string == "Carthago delenda est":
    print('And so it was! For the glory of Rome!')
else:
    print('War elephants are TERRIFYING. I am staying home.')

And so it was! For the glory of Rome!

다음과 같이 문자열에도 < 또는 >와 같은 비교 연산자를 적용할 수 있습니다.

'apple' < 'banana'

True

'cat' < 'apple'

False

자세한 설명은 문자열의 사전식 순서 항목을 참고해 주세요.

몇몇 내장 함수들은 bool타입의 데이터를 반환합니다. 따라서 이들은 if문의 조건으로 바로 사용이 가능합니다. 사용자가 만든 함수가 bool 타입의 데이터를 반환한다면 이 또한 if문의 조건으로 사용이 가능합니다. 이에 대한 자세한 이야기는 뒤에서 다루도록 하겠습니다.

앞에서 잠깐 살펴봤던 in 키워드 또한 if 구문에 사용이 가능합니다.

if 'a' in my_string or 'e' in my_string:
    print('Those are my favorite vowels!')

Those are my favorite vowels!

반복문(Loop Structures)

반복문은 프로그래밍에서 가장 중요한 파트중 하나 입니다. for문과 while문은 내부의 코드 블럭을 반복적으로 실행하도록 해줍니다. while문의 경우 탈출조건이 참 값이라면 계속 코드가 실행됩니다. 어떤 시점에 탈출조건이 거짓이 된다면 그 다음 반복 시 반복문을 빠져나가게 됩니다. for문의 경우 어떤 수열(sequence)의 값을 따라서 반복문이 진행되고 수열이 끝나게 되면 반복문도 종료 됩니다.

i = 5
while i > 0: # 0이 False이기 때문에 이 부분은 'while i:' 라고 표기가 가능합니다.
    i -= 1
    print('I am looping! {0} more to go!'.format(i))

I am looping! 4 more to go!
I am looping! 3 more to go!
I am looping! 2 more to go!
I am looping! 1 more to go!
I am looping! 0 more to go!

while 문을 사용할 때에는 탈출조건에 들어간 값이 루프가 반복됨에 따라 변화함을 항상 확인해야 합니다. 그렇지 않으면 탈출조건이 항상 참이 되고 무한 루프에 빠지게 됩니다. 위의 예제에서 i라는 변수를 탈출조건에 사용하였고 i 값은 루프 내부에서 i -= 1(i = i - 1의 줄임 명령어)이라는 명령어를 통해 변화하게 됩니다. 루프가 반복되면서 i 값은 점점 줄어들게 되고 0이 되는 순간이 있게 됩니다. 그 다음 루프가 시작하기 전 탈출조건이 False가 되고 루프에서 탈출하게 됩니다. 그래서 출력된 결과를 보시면 0 까지 프린트가 되어 있습니다.

for문은 지정된 횟수만큼만 반복을 실행합니다. 아래와 같이 range()함수를 사용할 경우 i 값이 range(5)에 해당하는 [0,1,2,3,4,5] 내부의 값들을 가지면서 반복이 실행됩니다.

for i in range(5):
    print('I am looping! I have looped {0} times!'.format(i + 1))

I am looping! I have looped 1 times!
I am looping! I have looped 2 times!
I am looping! I have looped 3 times!
I am looping! I have looped 4 times!
I am looping! I have looped 5 times!

위에서 in 키워드를 통해 해당 데이터가 자료구조에 들어있는지 여부를 파악한다고 배웠습니다. 하지만 이 in 키워드는 위와 같이 for문을 구성하는데도 사용됩니다. in 키워드 뒤에는 리스트, 튜플, 집합(set)과 같은 다른 자료구조들도 올 수 있습니다.

my_list = {'cats', 'dogs', 'lizards', 'cows', 'bats', 'sponges', 'humans'} # Lists all the animals in the world
mammal_list = {'cats', 'dogs', 'cows', 'bats', 'humans'} # Lists all the mammals in the world
my_new_list = set()
for animal in my_list:
    if animal in mammal_list:
        # This adds any animal that is both in my_list and mammal_list to my_new_list
        my_new_list.add(animal)
        
print(my_new_list)

{'humans', 'dogs', 'cats', 'bats', 'cows'}

for와 while문 같은 반복문을 구성할 때 break와 continue 구문을 활용하여 손쉽게 반복문을 다룰 수 있습니다. 먼저 루프가 실행되는 동안 어디서든 break 구문을 마주치게 되면 반복문을 즉시 탈출합니다.

i = 10
while True:
    if i == 14:
        break
    i += 1 # i = i + 1 과 같은 표현 입니다.
    print(i)

11
12
13
14

for i in range(5):
    if i == 2:
        break
    print(i)

0
1

루프가 돌다가 continue 구문을 만난다면 그 루프를 넘어가고 다음 루프로 바로 진행하게 됩니다.

i = 0
while i < 5:
    i += 1
    if i == 3:
        continue
    print(i)

1
2
4
5

위의 출력 결과를 살펴보면 $3$이 없음을 확인할 수 있습니다. 이는 i가 3이 되었을 때 if문을 통해 조건에 걸리게 되고 contine 구문을 만나 i를 출력하는 일 없이 바로 다음 루프로 넘어가기 때문입니다.

반복을 위해 사용된 변수(예제에서 i) 또는 반복문 내부에서 정의된 변수는 반복 루프가 끝나더라도 값이 지워지지 않고 루프가 끝날 때의 값을 유지합니다. 다음 예제에서 루프가 끝났을 때 i값이 4로 유지됨을 확인 할 수 있고 루프 내부에서 정의된 loop_string 값도 그대로 살아있음을 볼 수 있습니다.

for i in range(5):
    loop_string = 'I transcend the loop!'
    print ('I am eternal! I am {0} and I exist everywhere!'.format(i))

print ('I persist! My value is {0}'.format(i))
print (loop_string)

I am eternal! I am 0 and I exist everywhere!
I am eternal! I am 1 and I exist everywhere!
I am eternal! I am 2 and I exist everywhere!
I am eternal! I am 3 and I exist everywhere!
I am eternal! I am 4 and I exist everywhere!
I persist! My value is 4
I transcend the loop!

딕셔너리 자료형도 for문을 통해 반복할 수 있습니다.

my_dict = {'firstname' : 'Inigo', 'lastname' : 'Montoya', 'nemesis' : 'Rugen'}

for key in my_dict:
    print(key)

firstname
lastname
nemesis

위와 같이 딕셔너리를 in 키워드를 통해 반복시키면 자동적으로 key 값이 반복되어 집니다. value 값에 접근하고자 한다면 다음과 같이 접근이 가능합니다.

for key in my_dict:
    print (my_dict[key])

Inigo
Montoya
Rugen

동시에 key, value 값을 다루고 싶다면 items()함수를 통해 하나의 루프에서 동시에 key-value 쌍에 접근이 가능합니다.

for key, value in my_dict.items():
    print(key, ':', value)

firstname : Inigo
lastname : Montoya
nemesis : Rugen

items()함수는 key-value 쌍을 튜플로 만들어 줍니다. 그 뒤 for 문에서 해당 튜플을 key, value 라는 변수에 unpacks 해 주고 반복이 진행되는것 입니다.

함수(Functions)

함수(Function)은 계산을 하거나, 데이터를 내보내거나, 당신이 원하는 것을 할 수 있는 재사용이 가능한 코드 블럭을 의미합니다. 프로그래밍 언어를 쓰는 이유 중 하나가 이런 함수를 만들어두고 재사용이 가능하기 때문입니다. 파이썬에 있는 내장함수 이외에도 우리가 원하는 함수를 자유롭게 만들어서 사용할 수 있습니다.

def hello_world():
    """ Prints Hello, world! """
    print('Hello, world!')

hello_world()

Hello, world!

for i in range(5):
    hello_world()

Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!

def명령어를 통해 함수를 정의(define) 할 수 있습니다.

def 함수이름(파라미터 목록):

    함수내용

    # 반환 값이 있다면 return을 통해 값을 지정해 줍니다.
    return (반환값)

처음 만든 hello_world() 함수는 호출 되면 언제나 문자열을 출력합니다. 따로 반환하는 값은 없습니다. 어떤 계산된 값이나 반환값이 필요하다면 그 값을 함수에서 반환(return) 해줘야 합니다. 또한 함수 내부에서 선언된 변수는 일반적으로 함수 바깥에서는 사용할 수 없습니다.

def see_the_scope():
    in_function_string = "I'm stuck in here!"

see_the_scope()
print(in_function_string)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-22-fb168f245f67> in <module>()
      3 
      4 see_the_scope()
----> 5 print(in_function_string)

NameError: name 'in_function_string' is not defined

변수의 범위는 해당 변수가 그 값과 연관되어 있는 코드의 범위를 의미합니다. 파이썬에서 함수의 경우 닫힌 범위(enclosed scope)를 가지게 됩니다. 이는 위에 코드에서 처럼 함수 밖에서는 함수 내부에서 만들어진 변수에 접근이 불가능함을 의미합니다. 함수 내부의 값을 밖에서 활용하기 위해서는 함수 내부에서 반환(return)을 해주어야 합니다. 반환된 값을 함수 밖에서 받는다면 문제 없이 값을 전달받을 수 있습니다.

다음 예제에서 처럼 함수 내부에서 선언된 변수를 return 함으로써 함수 바깥에서 사용하거나 출력할 수 있습니다.

def free_the_scope():
    in_function_string = "Anything you can do I can do better!"
    return in_function_string
my_string = free_the_scope()
print(my_string)

Anything you can do I can do better!

함수 바깥에서 내부의 변수를 받는것처럼 반대로 함수 바깥의 데이터를 함수로 전달도 가능합니다. 이는 파라미터를 설정함으로써 가능합니다.

def multiply_by_five(x):
    """ input에 5를 곱한값을 반환합니다. """
    return x * 5

n = 4
print(n)
print(multiply_by_five(n))

4
20

위의 예제에서는 x라는 하나의 파라미터를 사용하였지만 쉼표(,)를 통해 여러개의 파라미터를 추가할 수 있습니다.

def calculate_area(length, width):
    """ 직사각형의 넓이를 계산하여 반환합니다. """
    return length * width

l = 5
w = 10
print('Area: ', calculate_area(l, w))
print('Length: ', l)
print('Width: ', w)

Area:  50
Length:  5
Width:  10

만약 입력 받을 파라미터의 갯수가 정해지지 않았다면 별표기호(*)를 사용하여 이를 처리할 수 있습니다.

def sum_values(*args):
    sum_val = 0
    for i in args:
        sum_val += i
    return sum_val

print(sum_values(1, 2, 3))
print(sum_values(10, 20, 30, 40, 50))
print(sum_values(4, 2, 5, 1, 10, 249, 25, 24, 13, 6, 4))

6
150
343

위와 같이 몇개의 값들이 함수로 전달될지 모를 경우 *args와 같은 방식으로 입력을 받을 수 있습니다. 별표(*) 기호는 '이 함수가 임의의 개수로 값들을 받을 것이다.' 라는 것을 표시하는 파이썬 문법입니다. 이렇게 입력된 값들은 튜플(tuples)의 형태로 저장됩니다.

def test_args(*args):
    print(type(args))

test_args(1, 2, 3, 4, 5, 6)

<class 'tuple'>

위에서 쓴 *args라는 표현은 관습적인 표현으로 *vars 또는 *things와 같이 임의로 이름을 바꾸어 사용하여도 문제가 없습니다. 또한 함수 내부에서 args는 튜플 타입을 가지기 때문에 위에서 배운 방식으로 각 내용물에 접근이 가능합니다. 다만 튜플형의 특성상 내용물의 수정은 불가능 합니다.

우리가 만든 함수들은 어떤 데이터 타입이나 반환이 가능합니다. 함수가 bool타입을 반환하게 한다면 이를 조건(condition)으로 사용이 가능합니다. 예를 들어 알파벳 모음이 들어있는지 체크하여 모음이 들어있다면 True를 들어있지 않다면 False를 반환하는 함수를 다음과 같이 만들 수 있습니다.

def has_a_vowel(word):
    """ 
    단어에 모음이 들어가 있는지 확인하는 함수 입니다. 
    모음인 a,e,i,o,u 가 들어가 있다면 True를
    그렇지 않다면 False를 반환합니다.
    """
    vowel_list = ['a', 'e', 'i', 'o', 'u']
    
    for vowel in vowel_list:
        if vowel in word:
            return True
    # a,e,i,o,u 가 모두 없다면 False가 반환됩니다.
    return False

my_word = 'PJP'
has_a_vowel(my_word)

False

my_word = 'catnapping'
has_a_vowel(my_word)

True

if has_a_vowel(my_word):
    print('How surprising, an english word contains a vowel.')
else:
    print('This is actually surprising.')

How surprising, an english word contains a vowel.

def point_maker(x, y):
    """ 
    2차원 상의 x,y 좌표를 반환하는 함수입니다.
    사실 튜플과 같습니다.
    """
    return x, y

위의 함수는 숫자의 순서쌍을 입력받아 $R^2$ 공간의 한 점, (x,y)로 반환합니다.

a = point_maker(0, 10)
b = point_maker(5, 3)

def calculate_slope(point_a, point_b):
    """ 두 점을 지나는 직선의 기울기를 계산하여 반환합니다. """
    return (point_b[1] - point_a[1])/(point_b[0] - point_a[0])

print("The slope between a and b is {0}".format(calculate_slope(a, b)))

The slope between a and b is -1.4

위의 함수는 두 점을 지나는 직선의 기울기를 계산하여 반환하는 함수입니다.

이를 이용하여 다음과 같이 두 점을 지나는 직선의 방정식을 출력할 수 있습니다.

print("""The slope-intercept form of the line between a and b, using point a, is: y - {0} = {2}(x - {1})""".format(a[1], a[0], calculate_slope(a, b)))

The slope-intercept form of the line between a and b, using point a, is: y - 10 = -1.4(x - 0)

위에서 공부한 자료구조의 특성들과 코드 작성에 필요한 문법(syntax)을 잘 지키기만 한다면 어떤 계산이든 해서 값을 반환하는 함수를 손쉽게 만들 수 있습니다. 이는 모든 프로그래밍 언어에서 가장 중요한 부분이므로 잘 숙지해 두시길 바라겠습니다. 감사합니다.