[Python] 파이썬 문법 정리

자료형

# 지수 표현 방식
a = 1e9
print(a)

a = int(1e9)
print(a)

a = 75.25e1
print(a)

a = 3954e-3
print(a)

# IEEE754 표준에서는 실수형을 저장하기 위해 4 혹은 8바이트의 고정된 크기의 메모리를 할당
# 따라서 실수 정보를 표현햐는 정확도에 한계가 존재
a = 0.3 + 0.6
print(a)

if a == 0.9:
  print(True)
else:
  print(False)

# 따라서 round 함수를 이용해 반올림을 해준다.
a = 0.3 + 0.6
if round(a, 2) == 0.9: # 소수 셋째 자리에서 반올림
  print(True)
else:
  print(False)

# 파이썬에서 / 연산자는 나눠진 결과를 실수형으로 반환한다.
# 파이썬에는 몫을 얻기 위해 // 연산자를 사용한다.
# 이외에도 ** 연산자를 이용해 거듭 제곱과 제곱근을 구할 수 있다.
a = 5
b = 3

# 나누기
print(a / b)

# 나머지
print(a % b)

# 몫
print(a // b)

# 거듭 제곱
print(a ** b)

# 제곱근
print(a ** 0.5)

실행 결과
1000000000.0
1000000000
752.5
3.954
0.8999999999999999
False
True
1.6666666666666667
2
1
125
2.23606797749979

리스트

# 리스트
# 배열 혹은 테이블이라고 부르기도 한다.
# 배열의 기능 및 연결 리스트와 유사한 기능을 지원한다.

# 직접 데이터를 넣어 초기화
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a)

# 네 번째 원소 출력
print(a[3])

# 크기가 n이고, 모든 값이 0인 1차원 리스트 초기화
n = 10
a = [0] * n
print(a)

# 인덱싱
# 인덱스의 값을 입력하여 리스트의 특정 원소에 접근할 수 있다.
# 음의 정수를 사용하면 거꾸로 탐색하게 된다.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 여덟 번째 원소만 출력
print(a[7])

# 뒤에서 첫 번째 원소 출력
print(a[-1])

# 뒤에서 세 번째 원소 출력
print(a[-3])

# 네 번째 원소 값 변경
a[3] = 7
print(a)

# 슬라이싱
# 리스트에서 연속적인 위치를 갖는 원소를 가져올 수 있다.
# 끝 인덱스는 실제 인덱스보다 1을 더 크게 설정한다.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 두 번째 원소부터 네 번째 원소까지
print(a[1 : 4])

# 리스트 컴프리헨션
# 대괄호 안에 조건문과 반복문을 이용해 리스트를 초기화할 수 있다.

# 0부터 9까지의 수를 포함하는 리스트
a = [i for i in range(10)]
print(a)

# 0부터 19까지의 수 중에서 홀수만 포함하는 리스트
a = [i for i in range(20) if i % 2 == 1]
print(a)

# 1부터 9까지의 수들의 제곱 값을 포함하는 리스트
a = [i * i for i in range(1, 10)]
print(a)

# n x m 크기의 2차원 리스트 초기화
# n번 반복될 때 마다 길이가 m인 리스트가 생성된다.
n = 4
m = 3
a = [[0] * m for _ in range(n)] # _ : 반복을 위한 변수의 값 무시
print(a)

# 잘못된 방법
a = [[0] * m] * n
print(a)

a[1][1] = 5
print(a)

실행 결과
[1, 2, 3, 4, 5, 6, 7, 8, 9]
4
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
8
9
7
[1, 2, 3, 7, 5, 6, 7, 8, 9]
[2, 3, 4]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 5, 0], [0, 5, 0], [0, 5, 0], [0, 5, 0]]

 

리스트 관련 메서드

a = [1, 4, 3]
print("기본 리스트 : ", a)

# 리스트에 원소 삽입
a.append(2)
print("삽입 : ", a)

# 오름차순 정렬
a.sort()
print("오름차순 정렬 : ", a)

# 내림차순 정렬
a.sort(reverse = True)
print("내림차순 정렬 : ", a)

# 리스트 원소 뒤집기
a.reverse()
print("원소 뒤집기 : ", a)

# 특정 인덱스에 데이터 추가
a.insert(2, 3)
print("인덱스 2에 3 추가 : ", a)

# 특정 값인 데이터 개수 세기
print("값이 3인 데이터 개수 : ", a.count(3))

# 특정 값 데이터 삭제
a.remove(1)
print("값이 1인 데이터 삭제 : ", a)

a = [1, 2, 3, 4, 5, 5, 5]
remove_set = {3, 5} 

# remove_set에 포함되지 않은 값만을 저장
result = [i for i in a if i not in remove_set]
print(result)

실행 결과
기본 리스트 :  [1, 4, 3]
삽입 :  [1, 4, 3, 2]
오름차순 정렬 :  [1, 2, 3, 4]
내림차순 정렬 :  [4, 3, 2, 1]
원소 뒤집기 :  [1, 2, 3, 4]
인덱스 2에 3 추가 :  [1, 2, 3, 3, 4]
값이 3인 데이터 개수 :  2
값이 1인 데이터 삭제 :  [2, 3, 3, 4]
[1, 2, 4]

문자열, 튜플

# 문자열
# "", ''를 이용하여 초기화한다.
# 전체 문자열을 ""로 구성하는 경우, 내부적으로 '',
# 전체 문자열을 ''로 구성하는 경우, 내부적으로 ""를 포함시킬 수 있다.

data = 'Hello World'
print(data)

data = "Don't you know \"Python\"?"
print(data)

# 문자열 연산 
# 덧셈(+)을 이용하면 문자열이 더해져 연결된다.
# 양의 정수와 곱하는 경우, 문자열이 그 값만큼 여러 번 더해진다.
# 인덱싱과 슬라이싱 가능, 그러나 특정 인덱스의 값을 변경할 수 없다. (Immutable)
a = "Hello"
b = "World"
print(a + " " + b)

a = "String"
print(a * 3)

a = "ABCDEF"
print(a[2 : 4])

# 튜플
# 리스트와 유사, 그러나 한 번 선언된 값을 변경할 수 없다.
# 리스트는 []를 이용하지만 튜플은 ()를 이용한다.
# 1. 서로 다른 성질의 데이터를 묶어서 관리할 때
# ex) 최단경로 알고리즘에서 (비용, 노드번호)의 형태로 튜플 자료형을 자주 사용한다.
# 2. 데이터의 나열을 해싱(Hashing)의 키 값으로 사용할 때
# ex) 튜플은 변경이 불가능하므로 키 값으로 사용될 수 있다.
# 3. 리스트보다 메모리를 효유적으로 사용해야 할 때
# ex) 튜플은 리스트에 비해 상대적으로 공간 효율적이다. (기능 제한적, 메모리를 적게 사용함)

a = (1, 2, 3, 4, 5, 6, 7, 8, 9)

# 네 번째 원소만 출력
print(a[3])

# 두 번째 원소부터 네 번째 원소까지 출력
print(a[1 : 4])

실행 결과
Hello World
Don't you know "Python"?
Hello World
StringStringString
CD
4
(2, 3, 4)

딕셔너리(사전), 집합

# 딕셔너리
# 키와 값의 쌍을 데이터로 가지는 자료형이다.
# 변경 불가능한(Immutable) 자료형을 키로 사용할 수 있다.
# 딕셔너리는 해시 테이블을 이용하므로, 데이터의 조회 및 수정은 O(1)이 소요된다.

data = dict()
data['사과'] = 'Apple'
data['바나나'] = 'Banana'
data['코코넛'] = 'Coconut'

print(data)

if '사과' in data:
  print("'사과'를 키로 가지는 데이터가 존재합니다.")

# 딕셔너리 관련 메서드
# keys() : 키 데이터만 따로 뽑아서 리스트로 이용한다.
# values() : 값 데이터만 따로 뽑아서 리스트로 이용한다. 

key_list = data.keys()
value_list = data.values()

print(key_list)
print(value_list)

# 각 키에 따른 값을 하나씩 출력
for key in key_list:
  print(data[key])

# 집합
# 중복을 허용하지 않고 순서가 없는 자료형이다.
# 리스트 혹은 문자열을 이용해 초기화할 수 있다 : set() 
# 혹은 {} 안에 각 원소를 ,로 구분하여 초기화할 수 있다.
# 데이터의 조회 및 수정은 O(1)이 소요된다.

data = set([1, 1, 1, 2, 3, 4, 4, 5])
print(data)

data = {1, 1, 1, 2, 3, 4, 4, 5}
print(data)

# 집합의 연산
# 합집합 : A에 속하거나 B에 속하는 원소로 이루어진 집합
# 교집합 : A에도 속하고 B에도 속하는 원소로 이루어진 집합
# 차집합 : A(B)의 원소 중에서 B(A)에 속하지 않는 원소로 이루어진 집합

a = set([1, 2, 3, 4, 5])
b = set([3, 4, 5, 6, 7])

# 합집합
print(a | b)

# 교집합
print(a & b)

# 차집합
print(a - b)
print(b - a)

# 집합 관련 메서드
data = set([1, 2, 3])
print(data)

# 새로운 원소 추가
data.add(4)
print(data)

# 새로운 원소 여러 개 추가
data.update([5, 6])
print(data)

# 특정한 값을 갖는 원소 삭제
data.remove(3)
print(data)

실행 결과
{'사과': 'Apple', '바나나': 'Banana', '코코넛': 'Coconut'}
'사과'를 키로 가지는 데이터가 존재합니다.
dict_keys(['사과', '바나나', '코코넛'])
dict_values(['Apple', 'Banana', 'Coconut'])
Apple
Banana
Coconut
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6, 7}
{3, 4, 5}
{1, 2}
{6, 7}
{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6}
{1, 2, 4, 5, 6}

리스트나 튜플은 순서가 있기 때문에 인덱싱을 통해 자료형의 값을 얻을 수 있다.

그러나 딕셔너리와 집합은 순서가 없기 때문에 인덱싱으로 값을 얻을 수 없다. 대신, 딕셔너리의 키 혹은 집합의 원소를 이용해 O(1)의 시간 복잡도로 조회할 수 있다. (이때 키와 원소의 값은 변경 불가한(Immutable) 값이어야 한다.)

기본 입출력

# 기본 입출력
# input() : 한 줄의 문자열을 입력 받는 함수
# map() : 리스트의 모든 원소에 각각 특정한 함수를 적용하는 함수

# 데이터의 개수 입력
n = int(input())
print(n)

# 각 데이터를 공백을 기준으로 구분하여 입력
data = list(map(int, input().split()))
data.sort(reverse = True)
print(data)

# a, b, c를 공백을 기준으로 구분하여 입력
a, b, c = map(int, input().split())
print(a, b, c)

# 빠르게 입력받기
# sys 라이브러리에 내장된 sys.stdin.readLine() 메서드를 이용
# 입력 후 엔터가 줄 바꿈 기호로 입력되므로 rstrip() 메서드 함께 사용
import sys

# 문자열 입력 받기
data = sys.stdin.readline().rstrip()
print(data)

# 표준 출력 방법
# print() 함수를 이용하며 ,를 이용해 각 변수를 구분 가능
# 기본적으로 출력 이후에 줄 바꿈을 수행, 원치 않는 경우 end 속성 이용
a = 1
b = 2
print(a, b)
print(7, end=" ")
print(8, end=" ")

# 출력할 변수
answer = 7
print("정답은 " + str(answer) + "입니다.")

# f-string 
# 3.6부터 지원, 문자열 앞에 접두사 f를 붙여 사용
answer = 7
print(f"정답은 {answer}입니다.")

실행 결과
[입력 부분]
1
1
1 2 3
[3, 2, 1]
1 2 3
1 2 3
baboya
baboya
[출력 부분]
1 2
7 8 정답은 7입니다.
정답은 7입니다.

조건문

# 들여쓰기
# 파이썬 공식 가이드라인에서는 '4개의 공백 문자'를 들여쓰기 표준으로 설정

# 조건문 기본 형태
# if 조건문 1:
#     조건문이 1이 True일 때 실행되는 코드
# elif 조건문 2:
#     조건문 1에 해당하지 않고, 조건문이 2가 True일 때 실행되는 코드
# else:
#     위의 모든 조건문이 True 값이 아닐 때 실행되는 코드

# 조건문 예제 : 성적 출력
score = 85

if score >= 90:
  print("학점 : A")
elif score >= 80:
  print("학점 : B")
elif score >= 70:
  print("학점 : C") 
else:
  print("학점 : F")

  # 논리 연산자
if True and True:
  print("True")
if True or False:
  print("True")
if not False:
  print("True")

a = 15

if a <= 20 and a >= 0:
  print("True")

# 기타 연산자
# x in 리스트 : 리스트 안에 x가 들어가 있을 때 True
# x not in 문자열 : 문자열 안에 x가 들어가 있지 않을 때 True

# pass 키워드
# 아무것도 처리하고 싶지 않을 때 사용
# 디버깅 과정에서 일단 조건문의 형태만 만들고, 처리 부분은 비워놓고 싶은 경우
if score >= 80:
  pass # 나중에 작성할 코드
else:
  print("성적이 80점 미만입니다.")
print("프로그램을 종료합니다.")

# 조건문의 간소화
# 조건문에서 실행될 코드가 한 줄인 경우, 줄 바꿈 필요 x
if score >= 80: result = "Success"
else: result = "Fail"
print(result)

# 조건부 표현식은 if ~ else문을 한 줄에 작성하게 해줌
result = "Success" if score >= 80 else "Fail"
print(result)

# 부등식 사용법
# 기존의 방식
x = 15
if x >= 0 and x < 20:
  print("x는 0 이상 20 미만의 수입니다.")

# 새로운 방식
if 0 <= x < 20:
  print("x는 0 이상 20 미만의 수입니다.")
  
실행 결과
학점 : B
True
True
True
True
프로그램을 종료합니다.
Success
Success
x는 0 이상 20 미만의 수입니다.
x는 0 이상 20 미만의 수입니다.

반복문

# while문
i = 1
result = 0

# 1 ~ 9까지의 합
while i <= 9:
  result += i;
  i += 1

print(result)

i = 1
result = 0

# 1 ~ 9까지 홀수의 합
while i <= 9:
  if i % 2 == 1:
    result += i
  i += 1

print(result)

# for문
# for 변수 in 리스트:
#   실행할 소스코드
arr = [9, 8, 7, 6, 5]
for x in arr:
  print(x)

# range() : 연속적인 값을 차례대로 순회할 때 주로 사용
# range(시작 값, 끝 값 + 1) 형태
# 인자를 하나만 넣으면 자동으로 시작 값은 0이 된다.
result = 0

# i는 1부터 9까지의 모든 값을 순회
for i in range(1, 10):
  result += i

print(result)

# continue
# 반복문에서 남은 코드의 실행을 건너뛰고 다음 반복을 진행할 때 사용
result = 0

# 1 ~ 9까지 홀수의 합
for i in range(1, 10):
  if i % 2 == 0:
    continue
  result += i

print(result)

# break
# 반복문을 즉시 탈출할 때 사용
i = 1

while True:
  print("현재의 값 : ", i)
  if i == 5:
    break
  i += 1

# 학생들의 합격 여부 판단 예제
scores = [90, 85, 77, 65, 97]

for i in range(5):
  if scores[i] >= 80:
    print(i + 1, "번 학생은 합격입니다.")

cheating_student_list = {2, 4}

for i in range(5):
  if i + 1 in cheating_student_list:
    continue
  if scores[i] >= 80:
    print(i + 1, "번 학생은 합격입니다.")

# 중첩 반복문, 구구단 예제
for i in range(2, 10):
  for j in range(1, 10):
    print(i, "X", j, "=", i * j)
  print()
  
실행 결과
45
25
9
8
7
6
5
45
25
현재의 값 :  1
현재의 값 :  2
현재의 값 :  3
현재의 값 :  4
현재의 값 :  5
1 번 학생은 합격입니다.
2 번 학생은 합격입니다.
5 번 학생은 합격입니다.
1 번 학생은 합격입니다.
5 번 학생은 합격입니다.
2 X 1 = 2
2 X 2 = 4
2 X 3 = 6
2 X 4 = 8
2 X 5 = 10
2 X 6 = 12
2 X 7 = 14
2 X 8 = 16
2 X 9 = 18
...
(중략)

함수와 람다 표현식

# 함수
# 특정한 작업을 하나의 단위로 묶어 놓은 것을 의미
# 불필요한 소스코드의 반복을 줄일 수 있다.

# 함수의 종류
# 내장 함수 : 파이썬이 기본적으로 제공하는 함수
# 사용자 정의 함수 : 개발자가 직접 정의하여 사용할 수 있는 함수

# 함수 정의하기
# def 함수명(매개변수):
#     실행할 소스코드
#     return 반환 값

# 더하기 함수 예시
def add(a, b):
  return a + b

print(add(3, 7))

def add(a, b):
  print("함수의 결과 : ", a + b)

add(3, 7)

# 파라미터의 변수 직접 지정하기
add(b = 3, a = 7)

# global
# 지역 변수가 아닌 함수 바깥에 선언된 변수를 바로 참조
a = 0

def func():
  global a # 위에서 선언한 a를 참조
  a += 1

for i in range(10):
  func()

print(a)

arr = [1, 2, 3, 4, 5]

def func():
  global arr
  arr = [3, 4, 5]
  arr.append(6)

func()
print(arr)

# 여러 개의 반환 값
def operator(a, b):
  add_var = a + b
  substract_var = a - b
  multiply_var  = a * b
  divde_var = a / b
  return add_var, substract_var, multiply_var, divde_var

a, b, c, d = operator(7, 3)
print(a, b, c, d)

# 람다 표현식
# 특정한 기능을 수행하는 함수를 한 줄에 작성할 수 있다.
print((lambda a, b: a + b)(3, 7))

# 자주 사용되는 람다 함수
arr = [("홍길동", 50), ("이순신", 32), ("아무개", 74)]

# 두 번째 원소를 기준으로 정렬한다.
def my_key(x):
  return x[1]

print(sorted(arr, key=my_key))
print(sorted(arr, key=lambda x: x[1]))

# 여러 개의 리스트에 적용
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

result = map(lambda a, b: a + b, list1, list2)

print(list(result))

실행 결과
10
함수의 결과 :  10
함수의 결과 :  10
10
[3, 4, 5, 6]
10 4 21 2.3333333333333335
10
[('이순신', 32), ('홍길동', 50), ('아무개', 74)]
[('이순신', 32), ('홍길동', 50), ('아무개', 74)]
[7, 9, 11, 13, 15]

유용한 표준 라이브러리

# 내장 함수
# 입출력 함수부터 정렬 함수까지 기본적인 함수들을 제공
# sum()
result = sum([1, 2, 3, 4, 5])
print(result)

# min(), max() 
min_result = min(7, 3, 5, 2)
max_result = max(7, 3, 5, 2)
print(min_result, max_result)

# eval() 
result = eval("(3 + 5) * 7")
print(result)

# sorted()
result = sorted([9, 1, 8, 5, 4])
reverse_result = sorted([9, 1, 8, 5, 4], reverse=True)
print(result)
print(reverse_result)

# sorted() with key
arr = [("홍길동", 35), ("이순신", 75), ("아무개", 50)]
result = sorted(arr, key=lambda x: x[1], reverse=True)
print(result)

# itertools
# 파이썬에서 반복되는 형태의 데이터를 처리하기 위한 유용한 기능들을 제공
# 순열과 조합 라이브러리는 코테에서 자주 사용된다.

# 순열 : ABC, ACB, BAC, BCA, CAB, CBA
from itertools import permutations

data = ['A', 'B', 'C'] 

result = list(permutations(data, 3)) # 모든 순열 구하기
print(result)

# 조합 : AB, AC, BC 
from itertools import combinations

result = list(combinations(data, 2))
print(result)

# 중복 순열과 중복 조합
from itertools import product

result = list(product(data, repeat=2)) # 2개를 뽑는 모든 순열 구하기 (중복 허용)
print(result)

from itertools import combinations_with_replacement

result = list(combinations_with_replacement(data, 2)) # 2개를 뽑는 모든 조합 구하기 (중복 허용)
print(result)

# heapq
# 힙 자료구조를 제공
# 우선순위 큐 기능을 구현하기 위해 사용된다.

# bisect
# 이진 탐색 기능을 제공한다.

# collections
# 덱(deque), 카운터(Counter) 등의 유용한 자료구조를 포함한다.

# deque
# 큐를 구현할 때 보통 사용한다.
# 별도로 제공하는 Queue 라이브러리는 일반적인 큐 자료구조와 조금 다르다.
# 리스트와 다르게 인덱싱, 슬라이싱 등의 기능은 사용할 수 없다.
from collections import deque

data = deque([2, 3, 4])

data.appendleft(1) # O(1)
data.append(5) # O(1)
print(list(data))

data.popleft() # O(1)
data.pop() # O(1)
print(list(data))

# Counter
# 등장 횟수를 세는 기능을 제공 
# 리스트와 같은 반복 가능한 객체가 주어진 경우 내부의 원소가 몇 번씩 등장했는지 알려준다.
from collections import Counter

counter = Counter(["red", "blue", "red", "green", "blue", "blue"])

print(counter["blue"])
print(counter["green"])
print(dict(counter)) # 딕셔너리 형태로 변환

# math
# 필수적인 수학적 기능을 제공
# 팩토리얼, 제곱근, 최대공약수, 삼각함수 관련 함수 등을 포함한다.

# 팩토리얼
import math

print(math.factorial(5))

# 제곱근
print(math.sqrt(7))

# 최대공약수/최소공약수
def lcm(a, b):
  return a * b // math.gcd(a, b)

a = 21
b = 14

print(math.gcd(a, b)) # 최대공약수 계산
print(lcm(a, b)) # 최소공약수 계산

# 파이(pi)와 자연상수(e)
print(math.pi)
print(math.e)

실행 결과
15
2 7
56
[1, 4, 5, 8, 9]
[9, 8, 5, 4, 1]
[('이순신', 75), ('아무개', 50), ('홍길동', 35)]
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]
[('A', 'B'), ('A', 'C'), ('B', 'C')]
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
[1, 2, 3, 4, 5]
[2, 3, 4]
3
1
{'red': 2, 'blue': 3, 'green': 1}
120
2.6457513110645907
7
42
3.141592653589793
2.718281828459045