[개발 공부 93일차] 파이썬 | 데이터 타입 (리스트, 튜플, set, 딕셔너리)

<목차 >

0. 리스트
1. 튜플
2. 집합 자료형 | set
3. 딕셔너리(Dictionary)

 

 

내가 사용할 자료들의 형태(Type)를 고민 → 자료형 결정 후, 담기

 

데이터 타입에는 리스트, 튜플, 집합, 딕셔너리가 있다.

# 리스트 (대괄호)
data_list = ["A", "a", 1, "@"]
data_list # 출력 결과: ['A', 'a', 1, '@']

# 튜플 (소괄호)
data_tuple = ("A", "a", 1, "@")
data_tuple # 출력 결과: ('A', 'a', 1, '@')

# 집합 (중괄호)
data_set = {"A", "a", 1, "1", "@"}
data_set # 출력 결과: {'1', 1, '@', 'A', 'a'} 

# 딕셔너리 (중괄호)
data_dictionary = {"A": "a", 3: "@"}
data_dictionary # 출력 결과: {'A': 'a', 3: '@'}

 

 

리스트

순서가 있는 변수의 모음이다.

• [ ] 로 리스트 생성
• 거의 모든 종류의 데이터가 리스트에 들어갈 수 있음
• 변수명 = [값1, 값2, …]
• 변수명 = list(문자형 자료 or 범위형 자료)

a = []
type(a) # 출력 결과: <class 'list'>

a = [1, 2, "문자", True, ["A", "a"]]
a  # 출력 결과: [1, 2, '문자', True, ['A', 'a']]

 

 

[리스트] list()로 변수를 리스트로 만들기

a_str = list("Python")
a_str # 출력 결과: ['P', 'y', 't', 'h', 'o', 'n']

 

 

[리스트] range()로 리스트 생성하기

a_num = list()
type(a_num) # 출력 결과: <class 'list'>

a_num = list(range(1, 100, 2)) # 2씩 뛰어넘음
a_num # 출력 결과: [1, 3, 5, 7, 9, 11, 13, ... 99]

 

 

리스트의 인덱싱

문자열 변수와 리스트 변수를 조작하는 것은 서로 유사하다.

a = ["Java", "JavaScript", "Python", "C", "C++", 1, 2, 3]
a[0] # 출력 결과: 'Java'
a[0] + str(a[5]) # 출력 결과: 'Java1'
a[1]*5 + a[3] # 출력 결과: 'JavaScriptJavaScriptJavaScriptJavaScriptJavaScriptC'

 

 

리스트의 슬라이싱

a = ["apple", "banana", "water melon", "strawberry"]
a[1:3] # 출력 결과: ['banana', 'water melon']
a[:2] # 출력 결과: ['apple', 'banana']
a[2:] # 출력 결과: ['water melon', 'strawberry']

 

 

리스트 안의 리스트 출력하기

a = ["apple", [1, 2, ["JS", "Python"]]]
a[1] # 출력 결과: [1, 2, ['JS', 'Python']]
a[1][1] # 출력 결과: 2
a[1][2][1] # 출력 결과: 'Python'

 

 

리스트 요소 수정 및 변경

# 값 1개를 수정할 때
a = ["a", "b", "c"]
a[1] = "B"
a # 출력 결과: ['a', 'B', 'c']

# [주의] 값 1개를 여러 개로 만들 때
a[1:2] = ["B", "C++", "JS"]
a # 출력 결과: ['a', 'B', 'C++', 'JS', 'c']

 

 

리스트 요소 삭제

a = ["1", "2", "3", "4", "5"]
del a[0]
a # 출력 결과: ['2', '3', '4', '5']

del a[0:2]
a # 출력 결과: ['4', '5']

del a[0:2]
a # 출력 결과: []

 

 

리스트의 다른 여러 명령어들 | 추가, 삽입

명령어	설명	예제	예제 해석
append()	리스트에 새 요소를 추가	a.append(”F”)	‘F’ 요소를 마지막 위치에 추가
insert()	리스트의 해당 위치에 요소를 새로 삽입	a.insert(2, ”B”)	2번 위치에 ‘B’를 추가
extend()	리스트의 맨 뒤에 새로운 리스트를 추가	a.extend([”G”, “H”])	리스트 [’G’, ‘H’]를 추가

a = ["a", "b", "c", "d", "e"]
a.append("e")
a # 출력 결과: ['a', 'b', 'c', 'd', 'e', 'e']

a.insert(2, "f")
a # 출력 결과: ['a', 'b', 'f', 'c', 'd', 'e', 'e']

a.extend(["g"])
a # 출력 결과: ['a', 'b', 'f', 'c', 'd', 'e', 'e', 'g']

 

 

리스트의 다른 여러 명령어들 | 세기, 찾기, 지우기

명령어	설명	예제
count()	해당 요소의 개수를 반환	a.count(”F”)
index()	해당 요소를 찾아 위치를 반환	a.index(2, ”B”)
remove()	해당 요소를 찾아 삭제	a.remove(”G”)

a = ["a", "b", "c", "d", "e"]
a.count("e")
a # 출력 결과: 1

a.index("d")
a # 출력 결과: 3

a.remove("e")
a # 출력 결과: ['a', 'b', 'c', 'd']

 

 

리스트의 다른 여러 명령어들 | 정렬, 개수 구하기

명령어	설명	예제
sort()	리스트를 오름차순으로 정렬	a.sort()
reverse()	리스트를 내림차순으로 정렬	a.reverse()
len()	리스트의 요소 개수를 구함	a.len(a)

a = [3, 1, 4, 5, 2]
a.sort()
a # 출력 결과: [1, 2, 3, 4, 5]

a.reverse()
a # 출력 결과: [5, 4, 3, 2, 1]

len(a) # 출력 결과: 5

 

 

Practice. 출석 번호 재정렬

at = ["JK", "RM", "JIN", "J-HOPE", "JIMIN", "SUGA"]
print("참석한 멤버는 %s" %at)
a = input("지각한 멤버는: ")
b = 0
at.append(a)
print(at)
print("번호 재정렬")
at.sort()

for i in at:
	b = b + 1
	print(b, i)

# 참석한 멤버는 ['JK', 'RM', 'JIN', 'J-HOPE', 'JIMIN', 'SUGA']
# 지각한 멤버는: V
# ['JK', 'RM', 'JIN', 'J-HOPE', 'JIMIN', 'SUGA', 'V']
# 번호 재정렬
# 1 J-HOPE
# 2 JIMIN
# 3 JIN
# 4 JK
# 5 RM
# 6 SUGA
# 7 V

 

 

튜플

: 원소의 추가, 삭제, 변경이 불가능한 자료형 ⇒ 신뢰성을 갖는 타입

 

 

튜플 생성

• 소괄호()로 생성
• 튜플명 = (값1, 값2, …)
• 튜플명 = tuple(자료)
• tuple()로 튜플 생성
• range()로 값 생성

a = (1, 2, 3)
type(a) # 출력 결과: <class 'tuple'>

b = 1, 2, 3
type(b) # 출력 결과: <class 'tuple'>
# 괄호를 생략할 수 있으나 생략하지 않는 것을 권함

a = [1, "가", 2, "나"]
b = tuple(a)
b # 출력 결과: (1, '가', 2, '나')

# tuple()로 튜플 생성 & range()로 값 생성
c = tuple(range(1, 15, 2))
c # 출력 결과: (1, 3, 5, 7, 9, 11, 13)

 

 

튜플 조작하기

• 인덱싱
• 슬라이싱
• 튜플 → 리스트로 변경

# 인덱싱
a = (1, 2, 3, 4, 5)
a[2] # 출력 결과: 3

# 슬라이싱
a[1:3] # 출력 결과: (2, 3)

# 튜플을 리스트로 변경
b = list(a)
b # 출력 결과: [1, 2, 3, 4, 5]

 

 

튜플 안의 값 확인 | in, not in

: 해당 값이 있는지 없는지 확인

a = (1, 2, 3, 4, 5, 4, 3, 2, 1)
3 in a # 출력 결과: True
3 not in a # 출력 결과: False
6 not in a # 출력 결과: True

 

 

튜플 조작

• 개수 세기: count()
• 인덱스 찾기: index() 사용

a = (1, 2, 3, 4, 5, 4, 3, 2, 1)
a.count(3) # 출력 결과: 2
a.index(5) # 출력 결과: 4

 

 

• 패킹
• 언패킹

pack = 1, 2, 3, 4, 5, 4, 3, 2, 1 # 패킹
a, b, *c = pack # 언패킹
print("a는 %d, b는 %d" %(a, b), "c는" c) # 출력 결과: a는 1, b는 2, c는 [3, 4, 5, 4, 3, 2, 1]

# 값 2개를 서로 바꾸기
a, b = b, a
print("a는 %d, b는 %d" %(a, b)) # 출력 결과: a는 1, b는 2

 

 

Practice. 튜플 조작하기

print("튜플에 입력할 자료를 차례로 입력하세요. 빈칸으로 구분합니다: ")
a = input()
a = tuple(a.split(" "))

while True:
	print("작업할 내용을 입력하세요.")
	b = input("q = 끝내기, s = 슬라이싱, c = 세기, i = 존재여부: ")
	
	if b == "q":
		print("프로그램 종료")
		break
	
	elif b == "s":
		c = int(input("From: "))
		d = int(input("To: "))
		if c < 0 or d > len(a):
			print("인덱스가 범위를 벗어났습니다.")
		else:
			print(a[c:d])
		
	elif b == "c":
		e = input("찾을 자료값은: ")
		print(a.count(e), "개 있습니다.")
		
	elif b == "i":
		f = input("찾을 자료값은: ")
		print(f in a)

 

 

집합 자료형 | set

: 순서와 중복 없이 저장된 자료형 { }

• 집합명 = {값1, 값2, …}
• 집합명 = set(자료 묶음 1개)
• 중복을 없애고 싶을 때 사용하면 좋다.

 

[예시]

a = {1, 2, 3, 4, 5},

b = {3, 4, 5, 6, 7},

c = {1, 2}일 때

• 모든 명령어는 set_union(a, b)와 같이 쓸 수도 있다.

연산	기호	명령어	결과
합집합	a | b	a.union(b)	{1, 2, 3, 4, 5, 6, 6}
교집합	a & b	a.intersection(b)	{3, 4, 5}
차집합	a - b	a.difference(b)	{1, 2}
대칭차집합	a^b	a.symmetric_difference(b)	{1, 2, 6, 7}
부분집합 검사하기	c <= a	c.issubset(a)	True
상위집합 검사하기	c >= a	c.issuperset(a)	False
서로소 검사하기		c.isdisjoint(b)	True

 

a = set([1, 2, 3, 4, 5])
b = {3, 4, 5, 6, 7}
a | b # 출력 결과: {1, 2, 3, 4, 5, 6, 7}

 

 

기타 명령어

종류	명령어	예제	결과
특정값 확인	in not in	2 in a 2 not in a	True False
추가	add update	a.add(6) a.update({6})	{1, 2, 3, 4, 5, 6}
삭제 (없을 시, 에러)	remove	b.remove(8)	KeyError
삭제	discard	b.discard(8)	{3, 4, 5, 6, 7}
임의 값 추출 후 삭제	pop	a.pop()	1 or 2 … or 5
세트 삭제	del	del a	세트 a 삭제
세트 내 값 삭제	clear	a.clear()	{}
최대값	max	max(a)	5
최소값	min	min(a)	1

 

 

Practice. 약수와 공약수 출력하기

a = int(input("첫 번째 수: "))
b = int(input("두 번째 수: "))

# 집합 생성
aa = set()
bb = set()

for i in range(1, a+1):
	if a % i == 0:
			aa.add(i)
print("첫 번째 수의 약수: ", aa)
	
for i in range(1, b+1):
	if b % i == 0:
			bb.add(i)
print("첫 번째 수의 약수: ", bb)

print("%d와 %d의 공약수는 " % (a, b) + str(aa&bb))

 

 

딕셔너리(Dictionary)

: key - value 쌍으로 이뤄진 자료형 { : }

• key: 변수 or 튜플
• value: 거의 모든 자료형 가능
• key는 변경 불가능, value는 변경 가능

a = {1: "A"}
a # 출력 결과: {1: 'A'}

# key값으로 추가하기
a["JS"] = 2
a # 출력 결과: {1: 'A', "JS": 2}

# del()로 삭제하기
del a["JS"]
a # 출력 결과: {1: 'A'}

# 딕셔너리 내부에 key 존재 여부 확인
a = {1: "apple", 2: "banana", "three": 3, "four": "4"}
2 in a # 출력 결과: True
333 in a # 출력 결과: False

# 값 추출 후, 해당 값 삭제 pop()
a.pop("three") # 출력 결과: 3
a # 출력 결과: {1: 'apple', 2: 'banana', 'four': '4'}

# key - value 추출하기 items()
a.items() # 출력 결과: dict_items([(1, 'apple'), (2, 'banana'), ('three', 3), ('four', '4')])

# key 추출하기 keys()
a.keys() # 출력 결과: dict_keys([1, 2, 'three', 'four'])

# 값 추출하기 values()
a.values() # 출력 결과: dict_values(['apple', 'banana', 3, '4'])

# 딕셔너리 초기화 clear()
a.clear()
a # 출력 결과: {}