Python 문법

작성일 | In

Spring

Python 기초 문법

산술 연산

  • + : +
  • − : -
  • × : *
  • ÷ (몫을 구하기) : //
  • ÷ (소수점까지 나누기) : /
  • 나머지 : %
  • 제곱 : **

비교 연산

  • > : 키보드 >
  • < : 키보드 <
  • = : 키보드 ==
  • \≠ : 키보드 !=
  • \≥ : 키보드 >=
  • \≤ : 키보드 <=

불리언 대수 (boolean algebra)

  • &(AND) 연산은 두 값이 모두 참일 때만 답이 참이 된다. 즉, 하나라도 거짓이면 답은 거짓이다.

  • |(OR) 연산은 두 값이 모두 거짓일 때만 답이 거짓이 된다. 즉, 하나라도 참이면 답은 참이다.

변수

1
2
3
    a = 2
    b = 3
    a * b

6

1
2
    a = 4
    (a > 0) & (a <= 10)

True

정수와 실수

1
2
3
10  # 정수
10.0  # 실수
.1  # .1 = 0.1 

1
2
3
4
10 * 5  # 정수

10.0 * 5  # 실수
10 / 5  # 실수

타입 확인

1
2
type(10)  # int
type(10.0)  # float

부동소수점 실수

1
2
123e2  # 123e2 = 123.0 x 100 = 12300.0
123.456e-3  # 123.456e-3 = 123.456 x 0.001 = 0.123456

십진법과 이진법

1
2
bin(3)
bin(15)

1
2
3
# Result
'0b11'
'0b1111'

부동소수점 오차

1보다 작은 수의 경우에는 십진법으로 간단히 표현되는 수도 이진법에서는 무한개의 유효숫자를 가질 수 있다. 예를 들어 0.1 이라는 숫자는 십진수로는 간단히 표현되지만 이진수로 나타내면 다음과 같이 0011(2)이 무한히 반복되는 실수가 된다.

1
0.1=0.00011001100110011001100110011001100110011001100110011001100110011

그런데 컴퓨터에서는 하나의 숫자를 나타내기 위한 메모리 크기가 제한되어 있어서 특정 소수점 이하는 생략하고 가장 비슷한 숫자로 표현할 수 밖에 없다. 0.1 은 실제로는 가장 비슷한 다음과 같은 숫자로 저장된다.

1
0.1≈0.1000000000000000055511151231257827021181583404541015625

그런데 파이썬 콘솔이나 주피터 노트북에서 0.1을 입력하면 다음과 같이 그냥 0.1로 나타난다.

1
0.1

그 이유는 파이썬 콘솔이나 주피터 노트북과 같은 REPL 인터페이스에서 값이 출력될 때는 편의상 일정 소수점 이하를 생략하고 보여주기 때문이다. 만약 소수점 이하 55자리까지 보고 싶으면 %precision 매직(magic) 명령어를 사용한다.

# 소숫점 55자리까지 표현 %precision 55

1
'%.55f'

이 상태에서 다시 0.1이라고 입력하면 55자리까지의 유효숫자를 보여준다.

1
0.1000000000000000055511151231257827021181583404541015625

다시 원래대로 돌아가려면 다음과 같이 입력한다.

%precision %r

이처럼 컴퓨터에서 실수를 계산할 때는 항상 미세한 오차를 가질 수 있으므로 실수의 계산을 할 때는 주의해야 한다. 예를 들어 0.1+0.2=0.3 이지만 파이썬에서 비교하면 다음처럼 양변이 다르다는 결과를 보인다.

1
0.1 + 0.2 == 0.3

자료형 변환

1
2
3
4
int(1.0)  # 실수를 정수로 변환
float(1)  # 정수를 실수로 변환
int(-3.9) # -3
int(3.14) # 3

NaN과 Inf

IEEE 754 표준에 따른 부동소수점 자료형은 특별한 두 가지 값을 표현할 수 있다. 하나가 NaN(Not a Number)이고 또 하나는 Inf(Infinity)이다.

NaN는 “숫자가 아닌 것”, Inf는 “무한대”를 뜻한다. 파이썬에서는 다음과 같은 명령으로 표현한다.

문자열 출력

1
2
3
4
print("Hello!")
print('한글도 쓸 수 있어요.')
print("내 이름은 " + "홍길동" + "입니다.")
print("*" * 10)

1
2
3
4
Hello!
한글도 쓸 수 있어요.
내 이름은 홍길동입니다.
**********

여러줄 문자열 출력

1
2
3
4
5
6
7
8
multi_line_string = """
파이썬(영어: Python)은 1991년 프로그래머인 
귀도 반 로섬(Guido van Rossum)이 발표한 고급 프로그래밍 언어로,
플랫폼 독립적이며 인터프리터식, 객체지향적, 동적 타이핑(dynamically typed) 
대화형 언어이다. 파이썬이라는 이름은 귀도가 좋아하는 코미디 〈Monty Python's Flying 
Circus〉에서 따온 것이다."""

print(multi_line_string)

1
2
3
4
5
파이썬(영어: Python)은 1991년 프로그래머인 
귀도 반 로섬(Guido van Rossum)이 발표한 고급 프로그래밍 언어로,
플랫폼 독립적이며 인터프리터식, 객체지향적, 동적 타이핑(dynamically typed) 
대화형 언어이다. 파이썬이라는 이름은 귀도가 좋아하는 코미디 〈Monty Python's Flying 
Circus〉에서 따온 것이다.

줄바꿈

1
2
3
4
print("한 줄 쓰고\n그 다음 줄을 쓴다.")
print("---")
print("한 줄 쓰고 ", end="")
print("이어서 쓴다.")

1
2
3
4
한 줄 쓰고
그 다음 줄을 쓴다.
---
한 줄 쓰고 이어서 쓴다.

문자열 변수

1
2
name = "홍길동"
print("내 이름은 " + name + "입니다.")

1
내 이름은 홍길동입니다.

문자열 치환

1
"2020.10.23".replace(".", "-")

1
'2020-10-23'

문자열의 공백을 없애려면 “ “ 공백 문자열을 “” 빈 문자열로 바꾸면 된다.

1
"word with space".replace(" ", "")

1
'wordwithspace'

문자열 형식화

형식지정 문자열 의미
%s 문자열
%d 정수
%f 부동소수점 실수 
1
"%d 곱하기 %d은 %d이다." % (2, 3, 6)

1
'2 곱하기 3은 6이다.'

고급 형식지정 문자열

고급 형식지정 문자열 의미
%20s 전체 20칸을 차지하는 문자열(공백을 앞에 붙인다.)
%-10d 전체 10칸을 차지하는 숫자(공백을 뒤에 붙인다.)
%.5f 부동소수점의 소수점 아래 5자리까지 표시

”[%20s]” % “*” # [와 ] 사이에 20칸의 공백이 있다.

1
'[                   *]'

”[%-20s]” % “A” # 20칸의 공백의 앞쪽에 A를 인쇄한다.

1
'[A                   ]'

”[%20d]” % 123 # 20칸의 공백의 뒷쪽에 123을 인쇄한다.

1
'[                 123]'

”[%-20d]” % 123 # 20칸의 공백의 앞쪽에 123을 인쇄한다.

1
'[123                 ]'

x = 1 / 3.0 # 값은 0.3333333…. “%.5f” % x # 소숫점 아래 5자리까지만 인쇄한다.

1
'0.33333'

”[%-20.6f]” % x # 20칸의 공백의 앞쪽에 소숫점 아래 6자리 출력

1
'[0.333333            ]'

format 메서드를 사용한 문자열 형식화

format 메서드를 사용하여 문자열을 형식화하는 방법도 있다. 이 때는 % 기호로 시작하는 형식지정 문자열 대신 {} 기호를 사용한다. 또한 자료형을 표시할 필요가 없다. 문자열 내에서 { 문자를 출력하고 싶을 때는 {{라는 글자를 사용한다.

“내 이름은 {}입니다.”.format(“홍길동”)

1
'내 이름은 홍길동입니다.'

“내 이름은 {{{}}}입니다.”.format(“홍길동”)

1
'내 이름은 {홍길동}입니다.'

“{2}의 {0} 점수는 {1}점입니다. {1}점! {1}점!”.format(“수학”, 100, “철수”)

1
"{2}의 {0} 점수는 {1}점입니다. {1}점! {1}점!".format("수학", 100, "철수")

“{a}점수: {x}점, {b}점수: {y}점”.format(a=”영어”, b=”수학”, x=100, y=90)

1
'영어점수: 100점, 수학점수: 90점'

format 방식에서 공백의 크기를 지정하거나 부동소수점의 소수점 아래 숫자를 지정할 때는 {}안에 : 기호를 넣고 그 뒤에 고급 형식지정 문자열을 넣는다. : 뒤에 오는 숫자는 공백의 크기를 뜻한다. <는 값을="" 앞쪽으로="" 붙이고="" 공백을="" 뒤로="" 붙인다.="" 반대로="">는 값을 앞쪽으로 붙이고 공백을 뒤로 붙인다. 소숫점의 자릿수를 지정할 때는 .(점)과 숫자, 그리고 f 글자를 사용한다. , 기호를 넣으면 영미권에서 숫자를 쓸 때 천(1000)단위마다 붙이는 쉼표(thousand comma)를 붙인다.

고급 형식지정 문자열 의미
{:>10} 전체 10칸을 차지하며 공백을 앞에 붙임 (문자열을 오른쪽에 붙여서 출력)
{:<10} 전체 10칸을 차지하며 공백을 뒤에 붙임 (문자열을 왼쪽에 붙여서 출력)
{:^10} 전체 10칸을 차지하며 공백을 앞뒤에 붙임 (문자열을 중앙에 붙여서 출력)
{:.5f} 부동소수점의 소수점 아래 5자리까지 표시
{:,} 천단위 쉼표 표시

”[{:<20}]”.format(“*”)

1
2
3
'[*                   ]' > "[{:>20}]".format("*")

'[                   *]'

”[{:^20}]”.format(“*”)

1
'[         *          ]'

”[{:20.5f}]”.format(1 / 3)

1
'[             0.33333]'

”[{:20,}]”.format(1234567890)

1
'[       1,234,567,890]'

만약 > 기호앞에 문자열을 쓰면 해당 문자열로 공백을 채운다.

고급 형식지정 문자열 의미
{:*>10} 전체 10칸을 차지하며 “*”을 앞에 붙임 (문자열을 오른쪽에 붙여서 출력)
{:*<10} 전체 10칸을 차지하며 “*”을 뒤에 붙임 (문자열을 왼쪽에 붙여서 출력)
{:*^10} 전체 10칸을 차지하며 “*”을 앞뒤에 붙임 (문자열을 중앙에 붙여서 출력)

”[{:-<20}]”.format(“*”)

1
'[*-------------------]'

”[{:->20}]”.format(“*”)

1
'[-------------------*]'

”[{:-^20}]”.format(“*”)

1
'[---------*----------]'

format 방법의 또다른 특징은 {}안에서 리스트나 사전의 인덱싱을 할수 있다는 것이다.

x = [10, 11, 12] “리스트의 첫번째 원소={0[0]}”.format(x)

1
2
3
'리스트의 첫번째 원소=10' >y = {"a": 10, "b": 11, "c": 12} "사전의 a키 값={0[a]}".format(y)

'사전의 a키 값=10'

f 문자열(f-string)

파이썬 3.6부터는 f 문자열(f-string)이라는 것을 사용할 수 있다. f 문자열은 문자열의 앞에 f 글자를 붙인 문자열이다. f 문자열에서는 {} 안에 변수의 이름을 바로 사용할 수 있다.

name = “홍길동” age = 32 print(f”{name}의 나이는 {age}살이다.”)

1
홍길동의 나이는 32살이다.

f 문자열에서 공백의 크기 등을 지정할 때는 format 방법과 같은 고급 형식지정 문자열을 사용할 수 있다.

if ~ else

1
2
3
4
5
6
a = 1

if a % 2 == 0:
    print("짝수")
else:
    print("홀수")

1
홀수

if ~ elif ~ else

1
2
3
4
5
6
7
8
c = 1

if c >= 10:
    print("A")
elif c >= 0:
    print("B")
else:
    print("C")

1
B

반복문

1
2
for i in range(10):
    print("=")

=

… =

1
2
for i in range(10):
    print(i)

1 2 … 10

예제 - 별찍기

1
2
3
a = 8
for i in range(a): 
    print('*' * (i+1))

1
2
3
4
5
6
7
8
*
**
***
****
*****
******
*******
********

1
2
3
4
a = 8
for i in range(a):
    print(" " * (a - (i+1)), end="")
    print('*' * (i+1))

1
2
3
4
5
6
7
8
       *
      **
     ***
    ****
   *****
  ******
 *******
********

1
2
3
4
a=8
for i in range(a):
    print(" " * (a - (i+1)), end="")
    print('*' * (2*i+1))

1
2
3
4
5
6
7
8
       *
      ***
     *****
    *******
   *********
  ***********
 *************
***************

1
2
3
4
5
6
7
8
# 방법 1
a=8
for i in range(a):
    print(" " * (a - (i+1)), end="")
    print('*' * (2*i+1))
for i in range(a):
    print(" " * ((i+1)), end="")
    print('*' * ((2*a-1)-2*(i+1)))

1
2
3
4
5
6
7
8
9
# 방법 2
a = 8
for i in range(a//2):
    print(' ' * (a//2 - i), end = '')
    print('*' * (2*i+1))

for i in range(a//2-1):
    print(' ' * (i + 2), end = '')
    print('*' * ((a//2*2)-3-2*i))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
       *
      ***
     *****
    *******
   *********
  ***********
 *************
***************
 *************
  ***********
   *********
    *******
     *****
      ***
       *

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 테스트용
a = 8
for i in range(a):
    if i < (a//2):
        for x in range(a-i):
            print(" ", end="")
        for x in range(2*i+1):
            print("*", end="")
    else:
        for x in range(a - i):
            print(" ", end="")
        for x in range(2*i+1 - a):
            print("*", end="")
        for x in range(a - (2*i+1 - a)):
            print(" ", end="")
        for x in range(2*i+1 - a):
            print("*", end="")
    print()

함수

파이썬에는 def 키워드와 return 키워드를 사용하여 다음과 같이 함수를 만들 수 있다. 파이썬에는 def 키워드와 return 키워드를 사용하여 다음과 같이 함수를 만들 수 있다.

1
2
3
4
5
def twotimes(x):
    y = 2 * x
    return y

twotimes(2)

1
1
4

입력이 여러 개인 함수

1
2
3
def add(x, y):
    return x + y
add(1, 2)

1
1
3

람다 함수*

1
2
def f(x):
return 2 * x

1
2
f = lambda x : 2 * x
f(2)

1
1
4

지역 변수

함수에 넣은 입력 변수나 함수 안에서 만들어진 변수는 함수 바깥에서는 사용할 수 없다. 혹시 이름이 같은 변수가 있다고 하더라도 별개의 변수가 된다.

따라서 함수 안에서 만들어지고 사용되는 함수를 지역 변수, 영어로 local variable 이라고 한다.

실제로 확인해 보자. 일단 함수 바깥에 혹시라도 y라는 변수가 있으면 del 명령으로 지운다.

1
del y

1
2
3
4
5
6
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-11-aa8f3401fc42> in <module>
----> 1 del y

NameError: name 'y' is not defined

기존에 y라는 변수가 없었으면 그런 변수가 없다는 오류가 나온다. 만약 기존에 y라는 변수가 있었으면 오류가 출력되지 않고 지워지기만 한다

이제 다음과 같이 y라는 이름의 지역 변수를 가지는 함수를 만들고 실행시킨다.

1
2
3
4
5
6
def f(x):
y = 10 * x
print("y = ", y)
return y

f(10)

1
2
y = 100
y

1
2
3
4
5
6
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-14-9063a9f0e032> in <module>
----> 1 y

NameError: name 'y' is not defined

전역 변수

하지만 지역 변수와 반대로 함수 바깥에서 만들어진 변수는 함수 안에서 사용할 수 있다. 이러한 변수를 전역 변수(global variable)이라고 한다.

1
2
3
4
5
6
7
8
9
10
z = 3

def f2(x):
    y = z * x
    print("y =", y)
    print("z =", z)
    return y
f2(10)
y = 30
z = 3

1
30

다만, 이때 바깥의 변수와 같은 이름의 변수를 함수 안에 만들면 안 된다. 만약 바깥의 변수와 같은 이름의 변수를 함수 안에 다시 만들면 함수 안에서는 그 지역 변수를 사용하다가 함수 바깥으로 나오면 지역 변수는 사라지고 원래의 변숫값으로 되돌아온다. 따라서 함수 안에서는 함수 바깥에 있는 변수의 값을 바꿀 수 없다.

z = 3

1
2
3
4
5
6
7
8
9
def f3(x):
    z = 99
    y = z * x
    print("y =", y)
    print("z =", z)
    return y
f3(10)
y = 990
z = 99

1
1
990

z

1
1
3

만약 함수안에서 함수 바깥에 있는 변수의 값을 꼭 바꿔야만 한다면 다음과 같이 함수 이름 앞에 global 키워드를 선언해 주면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
z = 3

def f4(x):
    global z
    z = 99
    y = z * x
    print("y =", y)
    print("z =", z)
    return y

f4(10)
y = 990
z = 99

1
1
990

z

1
99

여러 개의 자료를 한 변수에 담기

지금까지는 하나의 변수에 하나의 자료를 저장했다. 그러나 파이썬에서는 하나의 변수에 여러 개의 자료를 한꺼번에 저장하고 필요한 때 꺼내 쓸 수도 있다. 파이썬에서 하나의 변수에 여러 개의 자료를 저장하고 쓰는 데는 크게 두 가지 방법을 사용한다.

  • 여러 개의 자료가 순서가 있을 때는 리스트(list) 자료형 사용

  • 여러 개의 자료가 이름이 있을 때는 딕셔너리(dictionary) 자료형 사용

자료의 순서만 가지는 리스트 자료형

리스트 자료형에는 여러개의 자료를 순서에 따라 저장할 수 있다. 리스트 자료형 변수는 다음처럼 만든다.

이 때 자료의 개수는 얼마가 되든 상관없다.

1
x = [88, 90, 100]

1
[88, 90, 100]

인덱싱

1
(x[0] + x[1]) / 2

1
1
89.0

자료의 이름만 가지는 딕셔너리 자료형

파이썬에서는 자료의 이름을 키(key)라고 하고 자료의 값을 값(value)라고 한다.

1
2
    b = {"math": 88, "english": 90, "history": 100}
    b

1
{'math': 88, 'english': 90, 'history': 100}

딕셔너리 자료형 변수에서 특정한 자료를 꺼낼 때도 마찬가지로 인덱싱(indexing) 연산을 한다. 딕셔너리 자료형 변수에서 인덱싱 연산을 할 때도 다음처럼 대괄호(bracket)를 변수 이름 끝에 붙이고 그 안에 자료의 키를 넣는다.

1
(b["math"] + b["english"]) / 2

1
1
89.0

파이썬에서는 자료의 키는 무엇이든 가능하다. 즉, 숫자도 키가 될 수 있다.

1
2
b2 = {1: 10, 2: 20}
b2

1
{1: 10, 2: 20}

리스트와 딕셔너리에 들어가는 자료의 자료형

리스트 변수에는 자료형이 같은 자료만 담을 수 있는 것은 아니고 자료형이 다른 자료들도 담을 수 있다. 예를 들어 정수형 자료와 실수형 자료, 그리고 문자열 자료를 한 리스트 변수에 넣을 수도 있다.

1
d = [1, 3.14, "pi"]

심지어 리스트 변수에 또 다른 리스트 변수나 딕셔너리 변수를 넣을 수도 있다.

1
2
e = [[1, 10], [2, 20]]
f = [{0: 0, 1: 10}, {0: 1, 1: 2}]

1
2
e[1][1]     # 20
f[0]        # {0: 0, 1: 10}

딕셔너리 변수에도 여러가지 자료형의 자료를 넣을 수 있다.

1
2
3
4
g = {"a": [1, 2, 3], "b": {0: 1, 1: 2}}

g["a"]  # [1, 2, 3]
g["b"]  # {0: 1, 1: 2}

출처 : 데이터사이언스 스쿨

추가 예정…