[내가 보려고 적는 파이썬] 자료형

자료형

수 자료형(Number)

• 정수형(Integer)
  • 양의 정수
  • 음의 정수
  • 0

a = 1000 # 양의 정수  
print(a)

a = -7 # 음의 정수  
print(a)

# 0
a = 0  
print(a)

• 실수형(Real Number)
  • 소수점 아래의 데이터를 포함하는 수
  • 소수부가 0이거나, 정수부가 0인 소수는 0을 생략하고 작성할 수 있다.
  • 지수표현도 가능하다(1e9 는 10의 9승)

# 양의 실수
a = 157.93
print(a) # 157.93

# 음의 실수
a = -1837.2
print(a) # -1837.2

# 소수부가 0일 때 0을 생략
a = 5.
print(a) # 5.0

# 정수부가 0일 때 0을 생략
a = -.7
print(a) # -0.7

# 10억의 지수 표현 방식
a = 1e9
print(a) #1000000000.0

# 752.5
a = 75.25e1
print(a) # 752.5

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

• 주의할 점
  • 컴퓨터 시스템은 수 데이터를 처리할 때 2진수를 사용, 부동 소수점 방식을 사용한다.
  • IEEE754 표준에서는 실수형을 저장하기 위해 4, 8바이트라는 고정된 크기의 메모리를 할당
  • 현대 컴퓨터 시스템은 대체로 실수 정보를 표현하는 정확도에 한계를 가진다.
  • round() 함수를 활용하여 해결

a = 0.3 + 0.6
print(a) # 0.8999999999999999

if a == 0.9:
	print(True)
else
	print(False) ## False
  
if round(a, 4) == 0.9: # 보통 코딩테스트에서 다섯 번째 자리에서 반올림.
  print(True) ## True
else :
  print(False)

• 수 자료형의 연산
  • 사칙연산 ( +, - , *, /)
  • 나누기 연산자(/)는 기본적으로 실수형으로 처리한다.
  • 몫 (//)
  • 나머지(%)
  • 거듭제곱(**)

a = 7
b = 3

# 나누기
print(a/b) #2.3333333333333335

# 나머지
print(a%b) # 1

# 몫
print(a//b) # 2

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

리스트 자료형

C, Java에서 볼 수 있는 배열(Array) 기능을 포함하며, append(), remove() 등의 메서드를 지원하며 배열이나 테이블이라고도 부른다.

• 리스트 만들기
  • 대괄호([])안에 원소를 넣어 초기화, 쉼표로 원소를 구분한다.
  • 원소 접근시에는 Index값을 괄호 안에 넣는다. 인덱스는 0부터 시작한다.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
# 인덱스 4, 즉 다섯 번째 원소에 접근
print(a[4]) # 5
 
# 빈 리스트 선언방법
a = list()
print(a) # []
 
# 빈 리스트 선언방법
a = []
print(a) # []
  
# 크기가 N이고, 모든 값이 0인 1차원 리스트 초기화
n = 10
a = [0]* n
print(a) # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

• 리스트의 인덱싱과 슬라이싱
  • 리스트의 특정 원소에 접근하는 것을 인덱싱(Indexing)
  • 인덱스 값으로는 양의 정수(정방향)와 음의 정수(역방향)를 사용할 수 있다.
  • 대괄호 안 콜론(:)을 활용해 시작 인덱스와 (끝 인덱스-1)을 설정할 수 있다.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 뒤에서 첫 번째 원소 출력
print(a[-1]) # 9

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

# 네 번째 원소 값 변경
a[3] = 7
print(a) # [1, 2, 3, 7, 5, 6, 7, 8, 9]

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

• 리스트 컴프리헨션
  • 리스트를 초기화하는 방법 중 하나
  • 대괄호([]) 안에 조건문과 반복문을 넣는 방식으로 리스트를 초기화할 수 있다.

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

print(array) # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

# 일반적인 소스코드로 작성하면,
array = []
for i in range(20):
  if i % 2 == 1:
    array.append(i)
    
print(array)

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

print(array)

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

# 2차원 리스트 초기화시 자주 실수하는 점
n = 3
m = 4
array = [[0] * m] * n
print(array) # [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

# 동일한 객체에 대한 3개의 레퍼런스로 인식된다.
array[1][1] = 5
print(array) # [[0, 5, 0, 0], [0, 5, 0, 0], [0, 5, 0, 0]]

언더바(_)는 어떤 역할일까?

반복을 수행하되 반복을 위한 변수의 값을 무시하고자 할 때 언더바(_)를 자주 사용합니다.

• 리스트 관련 기타 메서드

메서드명	사용법	설명	시간 복잡도
append()	변수명.append()	리스트에 원소를 하나 삽입할 때 사용한다.	O(1)
sort()	변수명.sort(reverse=True)	오름차순으로 정렬, reverse는 내림차순	O(NlogN)
reverse()	변수명.reverse()	리스트의 원소의 순서를 모두 뒤집어 놓는다.	O(N)
insert()	insert(삽입할 인덱스, 삽입할 값)	특정한 인덱스 위치에 원소를 삽입할 때 사용한다.	O(N)
count()	변수명.count(특정 값)	리스트에서 특정한 값을 가지는 데이터의 개수 셈	O(N)
remove()	변수명.remove(특정 값)	특정한 값을 갖는 원소를 제거, 여러 개면 하나만 제거	O(N)

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

# 리스트에 원소 삽입
a.append(2)
print("삽입: ", a) # 삽입 : [1, 4, 3, 2]

# 오름차순 정렬
a.sort()
print("오름차순 정렬: ", a) # 오름차순 정렬 : [1, 2, 3, 4]

# 내림차순 정렬
a.sort(reverse = True)
print("내림차순 정렬: ", a) # 내림차순 정렬: [4, 3, 2, 1]

# 리스트 원소 뒤집기
a.reverse()
print("원소 뒤집기: ", a) # 원소 뒤집기: [1, 2, 3, 4]

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

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

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

insert() 함수와 append(), remove()

insert()의 복잡도는 O(N), 중간에 원소를 삽입한 뒤에 리스트의 원소 위치를 조정하기 때문

append()의 복잡도는 O(1), 제일 뒤에 삽입만 하기 때문

remove()의 복잡도는 O(N), 중간에 원소를 삭제한 뒤에 리스트의 원소 위치를 조정하기 때문

remove_all()과 같은 특정한 값을 가지는 모든 원소 제거 함수가 없으므로 다음과 같이 이용하자

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,2,4]

문자열 자료형

• 문자열 초기화
  • 큰따옴표(")나 작은따옴표(')를 이용한다.
  • 내부적으로 따옴표가 필요한 경우 반대되는 따옴표를 사용가능하다.
  • 또는 백슬래시()를 사용하면, 어느 따옴표든 추가가능하다.

data = 'Hello World'
print(data) # Hello World

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

• 문자열 연산
  • 덧셈(+)은 단순히 문자열을 더해져서 연결된다.
  • 곱셈은 그 값만큼 여러 번 더해진다.
  • 문자열도 리스트처럼 인덱싱과 슬라이싱을 이용할 수 있다.

a = "Hello"
b = "World"

print(a + " " + b) # Hellow World

print(a * 3) # HelloHelloHello

튜플 자료형

튜플은 리스트와 달리 두가지 특징이 있다.

• 튜플은 한 번 선언된 값을 변경할 수 없다.(대입 연산자(=)를 사용해 값을 변경할 수 없다.)
• 리스트는 대괄호([])을 이용하지만, 튜플은 소괄호(())를 이용한다.

a = (1, 2, 3, 4)
print(a)

a[2] = 7 # Error

• 소개
  • 그래프 알고리즘에서 주로 활용
  • 휴먼 에러를 방지하는데 활용
  • 리스트에 비해 공간 효율적
  • 원소의 성질이 서로 다를 때 주로 사용

사전 자료형

• 소개
  • 키와 값의 쌍을 데이터로 가지는 자료형
  • 내부적으로 '해시 테이블(Hash Table)'를 이용함( 검색 및 수정 : O(1))
• 장점
  • 범위가 넓으나 전체 데이터를 담을 필요가 없는 경우 활용
    • 예) 1부터 10,000,000까지로 구성된 번호에서 최대 10,000개의 번호를 선택하는 경우

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

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

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

• 사전 자료형 관련 함수
  • keys() : 키 데이터만 뽑아서 리스트로 활용
  • values() : 값 데이터만 뽑아서 리스트로 활용

# 키 데이터만 담은 리스트
key_list = data.keys()
# 값 데이터만 담은 리스트
value_list = data.values()
print(key_list) # dict_keys(['사과', '바나나', '코코넛'])
print(value_list) # dict_values(['Apple', 'Banana', 'Coconut'])

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

집합 자료형

• 집합(Set) 소개
  • 리스트 혹은 문자열을 이용해 만들 수 있다.(set([]) 이나 중괄호({})를 활용)
  • 중복을 허용하지 않는다.
  • 순서가 없다.
  • 사전 자료형과 비교해보면 값 데이터만을 담는다.
  • 검색 시간 복잡도는 O(1)이다
• 활용
  • 특정한 데이터가 이미 등장한 적이 있는지 여부를 체크

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

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

• 연산
  • 합집합( | )
  • 교집합( & )
  • 차지합( - )
• 관련 함수
  • add() : 값을 추가
  • remove() : 특정한 값을 제거
  • 둘 다 시간복잡도는 O(1)

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}

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

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

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

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

참고

• 변경 불가능한 자료형

  • 수 자료형
  • 문자열 자료형
  • 튜플 자료형

• 순서가 있는 자료형

  • 리스트
  • 튜플

• 순서가 없는 자료형

  • 집합
  • 사전

  해당 자료는 '이것이 코딩 테스트다 - 나동빈 저'를 공부하며 정리한 글입니다.