[python] 기본 문법 정리 - 수 / 리스트 / 문자열 / 튜플 / 사전 / 집합 자료형

*자료형

- 정수형: 양의 정수, 음의 정수, 0

- 실수형: 소수점 아래의 데이터를 포함하는 수 자료형. 소수점을 붙인 수를 대입하면 실수형 변수로 처리됨

 

* 지수 표현 방식

e나 E 다음에 오는 수는 10의 지수부

유효숫자e지수 = 유효숫자x10지수

ex) 1e9 = 10의 9제곱

 

지수 표현 방식은 실수형 데이터로 처리된다. 

임의 의 큰 수를 표현하기 위해 자주 사용된다. 

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

# 725.5
a = 75.25e1
print(a)

# 3.954
a = 3954e-3
print(a)

 

* 실수형 데이터는 오차가 있기 때문에 정확한 계산이 불가능해 원하는 결과를 얻지 못할 수 있다. 

이럴 때는 round() 함수를 이용할 수 있다. 

round(123.456, 2) -> 소수점 아래 둘째 자리까지 출력. 123.456을 소수 셋째 자리에서 반올림. 

결과는 123.46이 된다. 

 

* 나누기 연산자(/)는 나눠진 결과를 실수형으로 반환한다. (c, java는 정수형)

몫 연산자(//)

거듭제곱 연산자(**)

 

* 리스트

인덱스는 0부터 시작한다. 

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

print(a[3])

n = 10
a = [0] * n
print(a)

리스트 * n 하면 n번 반복된다. 

 

인덱싱: 인덱스 값을 입력하여 리스트의 특정한 원소에 접근하는 것

인덱스로 양의 정수, 음의 정수 사용 가능. 

음의 정수를 넣으면 거꾸로 탐색

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

# 8번째 원소 출력
print(a[7])

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

a[3] = 7
print(a)
# [1, 2, 3, 7, 5, 6, 7, 8, 9] 출력

 

* 슬라이싱: 연속적인 위치를 갖는 원소들 가져오기

[시작 인덱스 : 끝 인덱스+1]

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

# 2~4번째 원소 -> [2, 3, 4] 출력
print(a[1:4])

 

* 리스트 컴프리헨션: 리스트 초기화 방법 중 하나

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

# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 출력
print(array)

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

print(array)

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

print(array)

 

2차원 리스트를 초기화할 때 효과적

- 좋은 예시

# N X M 크기의 2차원 리스트 초기화
n = 4
m = 3
array = [[0] * m for _ in range(n)]

# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
print(array)

 

- 잘못된 예시

n = 4
m = 3
array = [[0] * m] * n
print(array)

array[1][1] = 5

# [[0, 5, 0], [0, 5, 0], [0, 5, 0], [0, 5, 0]]
print(array)

전체 리스트 안에 포함된 각 리스트가 모두 같은 객체로 인식된다. 따라서 값 하나를 바꾸면 n개의 리스트에 모두 똑같이 적용된다. 

 

* 언더바(_) 사용: 반복을 수행하되 반복을 위한 변수의 값을 무시하고자 할 때 사용

반복을 위한 변수값이 사용되지 않고 어떠한 동작을 반복하는 경우

for _ in range(5):
  print("Hello World!")

 

* 리스트 관련 기타 메서드

변수명.append() : 리스트에 원소 하나 삽입

변수명.sort() : 기본 정렬 기능. 오름차순 정렬

변수명.sort(reverse = True) : 내림차순 정렬

변수명.reverse() : 리스트의 원소 순서를 모두 뒤집어 놓음

insert(삽입할 위치 인덱스, 삽입할 값) : 특정한 인덱스 위치에 원소 삽입

변수명.count(특정 값) : 리스트에서 특정한 값을 가지는 데이터의 개수를 셀 때 사용

변수명.remove(특정 값) : 특정한 값을 갖는 원소를 제거하는데, 값을 가진 원소가 여러 개면 하나만 제거

a = [4, 3, 2, 1]

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

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

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

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

# 실행 결과
# 원소 뒤집기: [1, 2, 3, 4]
# 인덱스 2에 3 추가: [1, 2, 3, 3, 4]
# 값이 3인 데이터 개수: 2
# 값이 1인 데이터 삭제: [2, 3, 3, 4]

 

- 리스트에서 특정 값을 가지는 원소 모두 제거

a = [1, 2, 3, 4, 5, 5, 5]
remove_set = {3, 5}    # 집합 자료형

# result_set에 포함되지 않은 값만을 저장
result = [i for i in a if i not in remove_set]
print(result)		# [1, 2, 4] 출력

 

* 문자열

덧셈(+): 문자열이 더해져서 연결된다. 

곱셈(*): 문자열이 그 값만큼 여러 번 더해진다. 

문자열에 대해서도 인덱싱과 슬라이싱 이용 가능하다.

다만 문자열은 특정 인덱스의 값을 변경할 수 없다. (Innutable하다)

a = "Hello"
b = "World"
print(a + " " + b)

a = "String"
print(a * 3)

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

 

* 튜플

한 번 선언된 값을 변경할 수 없다. 

리스트에 비해 상대적으로 공간 효율적이다. (더 적은 메모리 사용)

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

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

# 2~4번째 원소까지 출력: (2, 3, 4)
print(a[1:4])

 

* 튜플을 사용하면 좋은 경우

- 서로 다른 성질의 데이터를 묶어서 관리해야 할 때

  : 최단 경로 알고리즘에서는 (비용, 노드 번호)의 형태로 튜플 자료형을 자주 사용한다. 

- 데이터의 나열을 해싱(Hashing)의 키 값으로 사용해야 할 때

  : 튜플은 변경이 불가능하므로 리스트와 다르게 키 값으로 사용될 수 있다. 

- 리스트보다 메모리를 효율적으로 사용해야 할 때

 

* 사전 자료형

: 키(Key)와 값(Value)의 쌍을 데이터로 가지는 자료형

키와 값의 쌍을 데이터로 가지며, 원하는 '변경 불가능한 자료형'을 키로 사용할 수 있다. 

사전 자료형은 해시 테이블을 이용하므로 데이터의 조회 및 수정에 있어서 O(1)의 시간에 처리할 수 있다. 

# 초기화
data = dict()

# 키, 값 할당
data['사과'] = "Apple"
data['바나나'] = "Banana"
data['코코넛'] = "Coconut"

# {'사과': 'Apple', '바나나': 'Banana', '코코넛': 'Coconut'}
print(data)

# 특정한 키에 매핑되는 값 촐력: Apple
print(data['사과'])

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

 

- keys() 함수: 키 데이터만 뽑아서 리스트로 이용

- values() 함수: 값 데이터만 뽑아서 리스트로 이용

# 키 데이터만 담은 리스트
key_list = data.keys()
print(key_list)

# 값 데이터만 담은 리스트
value_list = data.values()
print(value_list)

# 각 키에 따른 값을 하나씩 출력
for key in key_list: 
  print(data[key])
  
# 실행 결과
# dict_keys(['사과', '바나나', '코코넛'])
# dict_values(['Apple', 'Banana', 'Coconut'])
# Apple
# Banana
# Coconut

 

- 사전 자료형 초기화 방법

# 초기화 방법 1
a = dict()
a['홍길동'] = 97
a['이순신'] = 98
print(a)

# 초기화 방법 2
b = {
  '홍길동': 97,
  '이순신' : 98
}
print(b)

 

- keys() 함수는 사전 키라는 하나의 객체로 반환되기 때문에,  리스트 함수를 이용해서 리스트형 데이터로 형변환을 수행해줄 수도 있다. 

# dict_keys(['홍길동', '이순신']) 출력
key_list = b.keys()
print(key_list)

# ['홍길동', '이순신'] 출력
key_list = list(b.keys())
print(key_list)

 

* 집합 자료형

- 중복을 허용하지 않는다. 

- 순서가 없다. 

- 리스트 또는 문자열을 이용해서 초기화할 수 있다. 

  : set() 함수 이용

- 중괄호 안에 각 원소를 콤마 기준으로 구분하여 삽임함으로써 초기화할 수 있다. 

- 데이터의 조회 및 수정에 있어서 O(1)의 시간에 처리할 수 있다. 

 

- 집합 자료형 초기화 방법

# 집합 자료형 초기화 방법 1
data = set([1, 1, 2, 3, 4, 4, 5])
print(data)

# 집합 자료형 초기화 방법 2
data = {1, 1, 2, 3, 4, 4, 5}
print(data)

# 실행 결과
# {1, 2, 3, 4, 5}
# {1, 2, 3, 4, 5}

 

- 집합 연산

합집합, 교집합, 차집합

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

# 합집합
print(a | b)		# {1, 2, 3, 4, 5, 6, 7}

# 교집합
print(a & b)		# {3, 4, 5}

# 차집합
print(a - b)		# {1, 2}

 

- 집합 자료형 관련 함수 (add, update, remove)

data = set([1, 2, 3])
print(data)			# {1, 2, 3}

# 새로운 원소 추가
data.add(4)
print(data)			# {1, 2, 3, 4}

# 새로운 원소 여러 개 추가
data.update([5, 6])
print(data)			# {1, 2, 3, 4, 5, 6}

# 특정한 값을 갖는 원소 삭제
data.remove(3)
print(data)			# {1, 2, 4, 5, 6}

 

* 사전 자료형, 집합 자료형 특징

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

- 사전 자료형과 집합 자료형은 순서가 없기 때문에 인덱싱으로 값을 얻을 수 없다. 

  : 사전은 키로, 집합은 원소로 값을 조회할 수 있다. 이때 시간 복잡도는 O(1)이다. 

 

 

 

https://www.youtube.com/watch?v=m-9pAwq1o3w&list=PL4yUyjlDsKKep7CVBfp5ZU-vRHnrGQNRv&index=3