1. data type1: List(리스트형)
2. data type2: Tuple(튜플형)
3. data type3: Set(집합형)
4. data type4: Dictionary(사전형)
5. data type5: String(str, 문자형)
6. 5가지 데이터 타입끼리 변환하는 방법
1. data type1: List(리스트형)
파이썬의 데이터 타입 중 리스트는 대괄호 [ ] 를 이용하여 만듭니다. indexing(인덱싱), slicing(슬라이싱)이 가능하고 원소의 수정도 가능합니다.
> L=[1,2,3,4,5]
> print(L, len(L), type(L))
[1, 2, 3, 4, 5] 5 <class 'list'>
대괄호만 적으면 원소가 하나도 없는 빈 리스트가 만들어집니다.
> L1=[]
> print(L1, len(L1), type(L1))
[] 0 <class 'list'>
리스트 인덱싱(Indexing)
1부터 5까지 5개의 원소를 가지는 리스트 L로 indexing(인덱싱)을 해보겠습니다. 파이썬에서 인덱싱은 0부터 시작하므로 첫번째 원소를 인덱싱하고 싶다면 0을, 두번째 원소를 인덱싱하고 싶다면 1을, 뒤에서 두번째 원소를 인덱싱하고 싶다면 -2를, 마지막 원소를 인덱싱하고 싶다면 -1을 적습니다. 리스트에서 -1, len(L)-1, 4로 인덱싱한 결과가 모두 마지막 원소로 동일하게 나오는 것을 확인할 수 있습니다.
> print( L[-1], L[len(L)-1], L[4] )
5 5 5
이번엔 리스트를 원소로 가지는 리스트 L2를 만들었습니다. 리스트 L2를 1로 인덱싱하면 두번째 원소인 리스트 [2,3]이 나옵니다. 이 두번째 원소([2,3])의 첫번째 원소인 2를 불러오고 싶다면 순서대로 인덱싱하여 L2[1][0]를 적습니다.
> L2=[1, [2,3], 5]
> print(type(L2), type(L2[1], L2[1][0])
<class 'list'> <class 'list'> 2
리스트 원소 수정(변경)
인덱싱을 이용하여 리스트에 원소를 수정할 수 있습니다. 위에서 만든 리스트 L2의 마지막 원소인 5를 4로 변경하고 싶다면 마지막 원소를 인덱싱한 L2[-1]에 4를 할당합니다.
> L2[-1]=4
> L2
[1, [2, 3], 4]
리스트와 리스트에 +기호를 이용하여 연산하면 첫번째 리스트에 두번째 리스트의 모든 원소가 추가된(합쳐진) 새로운 리스트를 만들어집니다. 리스트의 모든 원소들을 특정 횟수(n)만큼 반복하고 싶다면 L*n을 적습니다.
> L+L2
[1, 2, 3, 4, 5, 1, [2, 3], 4]
> L*3
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
리스트 원소 추가(삽입)
append() 함수를 이용하여 리스트에 원소를 추가할 수 있습니다. 빈 리스트 L1에 append 함수를 적용하면, 적용한 순서대로 원소가 추가됩니다. +기호를 이용하여 2개 이상의 원소를 한번에 추가할 수도 있습니다. L1+=[4,5] 대신 L1=L1+[4,5]로 적어도 무방합니다.
> L1=[]
> L1.append(3)
> L1.append(2)
> L1.append(1)
> L1
[3, 2, 1]
> L1+=[4,5]
> L1
[3, 2, 1, 4, 5]
리스트 원소 제거(삭제)
remove() 함수를 이용하여 리스트의 특정 원소를 제거할 수 있습니다. pop() 함수를 이용하면 리스트의 마지막 원소를 삭제하고, 삭제한 원소를 출력합니다.
> L1.remove(4)
> L1.remove(5)
> L1
[3,2,1]
> L1=[1,2,3,4,5]
> L1.pop()
5
리스트에 있는 특정 원소 개수 세기
count()함수를 이용하면 리스트에 특정 원소가 몇 개 있는지 셀 수 있습니다.
> L4=[1,1,2,3]
> L4.count(1)
2
여러 변수에 값 할당
리스트를 이용하여 한번에 여러 변수에 값을 할당할 수 있습니다. 콤마(,)를 이용해 변수들을 적고 변수 개수에 맞게 리스트를 할당합니다.
> a, b, c=[1, 2, 3]
> print(a, b, c)
1 2 3
리스트 슬라이싱(Slicing)
슬라이싱을 이용하면 리스트 중 일부만 잘라낼 수 있습니다. 인덱싱과 마찬가지로 첫번째 원소를 0번째로 세어 마지막 원소를 -1번째로 세고, :를 이용하여 슬라이싱 합니다. L[a:b]는 (파이썬에서) a번째부터 b번째 전까지 슬라이싱 하는 것이므로 총 (b-a)개의 원소가 나옵니다. a=1, b=-1을 적으면 앞뒤로 하나씩의 원소를 제외하고 슬라이싱합니다. a를 생략하면 0으로, b를 생략하면 리스트의 길이인 len(L)로 간주합니다. a를 생략하고 b=-1로 적으면 마지막 원소 하나를 빼고 슬라이싱 하므로 마지막 원소만 제거하는 것과 결과가 같습니다.
> L=[1,2,3,4,5,6,7,8]
> L[0:4] #0번째(1) 부터 4번째(5) 전까지(4개)
[1, 2, 3, 4]
> print( L[1:-1], L[1:7]) #1번째(2)부터 마지막 전까지(6개)
[2, 3, 4, 5, 6, 7] [2, 3, 4, 5, 6, 7]
> L[:5] #0번째(1)부터 5번째(6) 전까지(5개)
[1, 2, 3, 4, 5]
> print(L[5:], L[5:len(L3)], L[5:8]) #5번째(6)부터 마지막 전까지(3개)
[6, 7, 8] [6, 7, 8] [6, 7, 8]
> L[:-1] #0번째(1)부터 마지막(8) 전까지(7개)
[1, 2, 3, 4, 5, 6, 7]
리스트 정렬(오름차순 나열, 내림차순 나열)
sort()함수를 이용하여 리스트의 원소를 나열할 수 있습니다. sort() 함수의 옵션을 안주면 오름차순 나열, reverse=True를 주면 내림차순으로 나열합니다. reverse()함수를 이용하면 현재 원소의 순서를 거꾸로 바꾸어 정렬(역순으로 정렬)합니다.
> L=[2,5,7,9,1,3,5,4,8,6,4]
> L.sort() #오름차순 나열
[1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 9]
> L.sort(reverse=True) #내림차순 나열
[9, 8, 7, 6, 5, 5, 4, 4, 3, 2, 1]
> L=[2,5,7,9,1,3,5,4,8,6,4]
> L.reverse() #역순으로 정렬
[4, 6, 8, 4, 5, 3, 1, 9, 7, 5, 2]
리스트의 원소 건너뛰기(슬라이싱, 홀수만 출력, 짝수만 출력)
:를 이용하여 리스트의 원소를 건너뛰어 출력할 수 있습니다. L[::2]는 0번째 부터 마지막 원소까지 두자리씩 건너뛰면서 출력 즉 홀수만 출력하는 것이고 L[0:len(L):2]와 동일합니다. L[1::2]는 1번째 부터 마지막 원소까지 두자리씩 건너뛰기 즉 짝수만 출력하는 것이고 L[1:len(L):2]와 동일합니다.
> L=[1,2,3,4,5,6,7,8,9,10]
> L[::2], L[0:len(L):2] #홀수만 출력
([1, 3, 5, 7, 9], [1, 3, 5, 7, 9])
> L[1::2], L[1:len(L):2] #짝수만 출력
([2, 4, 6, 8, 10], [2, 4, 6, 8, 10])
2. data type2: Tuple(튜플형)
파이썬의 튜플형 데이터 타입은 괄호()를 이용하여 만듭니다. 튜플은 인덱싱, 슬라이싱이 가능하지만, 리스트와 달리 원소의 수정이 불가능합니다. 따라서 데이터의 원소가 바뀌면 안되는 경우 튜플을 사용하면 좋습니다. 원소가 하나도 없는 빈 튜플은 ()만 입력하여 만듭니다.
> t=(1,2,3,4,5)
> t, type(t)
((1, 2, 3, 4, 5), tuple)
> t1=()
튜플의 인덱싱(Indexing)
tuple도 리스트와 마찬가지로 첫번째, 두번째, ..., 마지막 원소를 각각 0번째, 1번째, ..., -1번째로 세어 인덱싱합니다.
> t[0], t[-1] #0번째, -1번째(마지막) 원소
(1, 5)
리스트와 마찬가지로 +기호를 이용하여 튜플+튜플 연산을 하면 첫번째 튜플에 두번째 튜플의 모든 원소를 추가하여 새로운 튜플을 생성합니다. 튜플*n을 이용하여 튜플의 모든 원소를 n번씩 반복할 수 있습니다.
> t=(1,2,3,4,5)
> t2=(5,6,7)
> t+t2
(1, 2, 3, 4, 5, 5, 6, 7)
> t2*3
(5, 6, 7, 5, 6, 7, 5, 6, 7)
튜플의 슬라이싱(slicing)방법은 리스트와 동일하므로 생략하겠습니다.
3. data type3: Set(집합형)
파이썬에서 set 데이터 타입은 수학에서의 집합(set)과 동일하게 각 원소가 유일하고, 원소들은 순서를 갖지 않습니다. 순서를 갖지 않으므로 set은 인덱싱, 슬라이싱이 불가능합니다. set은 중괄호{}를 이용하여 만들지만 원소가 하나도 없는 공집합은 중괄호가 아닌 set()으로 만듭니다. 즉, set()은 집합형, {}는 바로 뒤에서 다룰 사전형(dictionary), ()는 tuple, []는 list입니다.
> s1={1,2,3,4,5}
> s1, type(s1)
({1, 2, 3, 4, 5}, set)
> s2=set() #공집합은 소괄호
> s2, type(set()), type({}), type(())
(set(), set, dict, tuple)
집합형(set)의 교집합, 합집합, 차집합
파이썬의 집합형은 수학에서의 집합과 동일하게 교집합, 합집합, 차집합 연산이 가능합니다. 두 집합에서 공통인 원소만 추출하는 교집합 연산은 & 기호 또는 intersection() 함수를 이용하고, 두 집합을 합쳐서 중복 없이 모든 원소를 나열하는 합집합 연산은 | 기호(shift+\)를 이용하고, 첫번째 집합에서 두번째 집합의 원소들을 제거하여 추출하는 차집합 연산은 - 기호를 이용합니다. 교집합과 합집합은 순서를 바꿔도 결과가 동일하지만, 차집합은 순서에 따라 결과가 달라집니다.
> s={1,2,3,4,5}
> s1={5,6,7}
> s & s1, s.intersection(s1), s1.intersection(s) #교집합(순서 상관x)
({5}, {5}, {5})
> s | s1 #합집합(순서 상관x)
{1, 2, 3, 4, 5, 6, 7}
> s - s1 #차집합
{1, 2, 3, 4}
집합(set)을 이용하여 중복 원소 제거
중복 원소를 가질 수 없다는 집합의 성질때문에, set()을 이용하여 집합형으로 변환하면 list(리스트), tuple(튜플) 등의 다른 타입의 데이터에서 중복 원소를 제거할 수 있습니다. 집합은 {}를 이용하여 입력하자마자 중복된 원소가 제거되어 출력됩니다.
> L=[1,2,2,2,3]
> L=set(L) #리스트를 집합으로 변환
> L
{1, 2, 3}
> t=(1,2,2,2,3)
> t=set(t) #튜플을 집합으로 변환
> t
{1, 2, 3}
> {1,1,2,2,3,3}
{1, 2, 3}
집합(set)의 원소 추가, 제거
list에서 append() 함수를 이용한 것과 비슷하게, set에선 add(), update() 함수를 이용하여 원소를 추가할 수 있습니다. 집합형의 원소는 순서를 가지지 않으므로 원소를 추가한 순서와 상관없이 오름차순 정렬됩니다. 또, list와 마찬가지로 remove() 함수를 이용하여 특정 원소를 제거할 수 있습니다.
> s2=set() #공집합
> s2.add(3) #원소 추가
> s2.add(2)
> s2.add(1)
> s2
{1, 2, 3}
> s2.update({4,5}) #원소 추가
> s2
{1, 2, 3, 4, 5}
>s2.remove(3) #원소 제거
>s2
{1, 2, 4, 5}
4. data type4: Dictionary(사전형)
파이썬의 dictionary(사전형) 데이터 타입의 원소는 key와 value의 대응되는 쌍으로 이루어져있고, 원소의 순서를 몰라도 key값으로 value를 찾을 수 있습니다. key는 중복없이 다 다른 값을 가지고 있어야 하며, 수정할 수 없는 immutable한 성질을 갖고 있습니다. key, value값엔 문자형(str), 정수(int)가 올 수 있습니다. dictionary는 중괄호를 이용하여 {'key1' : 'value1', 'key2' : 'value2'} 형태로 생성합니다. 원소가 하나도 없는 빈 dictionary는 {} 또는 dict()로 생성합니다.
> D1={ 'John' : '0011' , 'Maria' : '1234'}
> D1, type(D1)
({'John': '0011', 'Maria': '1234'}, dict)
> D2={} #집합 아님
> D98=dict()
> D2, type(D2), D98, type(D98), D2==D98
({}, dict, {}, dict, True)
사전형(dictionary)의 인덱싱(Indexing)
원소의 순서를 숫자로 넣어 인덱싱했던 list, tuple과 달리, dictionary는 key값을 넣어서 인덱싱하며 결과는 해당하는 value값이 나옵니다. key값을 넣을 때 큰 따옴표("")와 작은 따옴표('')모두 동일한 결과를 출력합니다.
> D1['John']
'0011'
> D2={"a":"1", "b":"2", "c":"3"}
> D2['a'], D2["a"]
('1', '1')
또, get() 함수를 이용하여 key값을 넣으면 해당하는 value를 가져와 인덱싱 할 수 있습니다.
> D2.get('a'), D2['a']
(1, 1)
사전형(dictionary) 원소 추가, 수정
dictionary에 특정 key값을 인덱싱하여 이에 대응하는 value를 삽입하여 원소를 추가할 수 있습니다. 이때 없는 key값을 인덱싱하면 원소를 추가하고, 이미 있는 key값을 인덱싱하면 해당하는 value를 수정합니다.
> D2={} #빈 dictionary
> D2['d']=4 #없는 key값이면 원소 추가
> D2['e']='5' #원소 추가
> D2[6]='g' #원소 추가
> D2[6]='f' #이미 있는 key값이면 value 수정
> D2
{'d': 4, 'e': '5', 6: 'f'}
dictionary에 keys() 함수를 이용하면 모든 key값을 보여주고, values() 함수를 이용하면 모든 value값을, items() 함수를 이용하면 모든 key와 value의 쌍을 보여줍니다. 3가지 함수 모두 대괄호[]를 이용하여 출력하지만 list는 아닙니다.
> D2.keys() #모든 key값
dict_keys(['d', 'e', 6])
> D2.values() #모든 value값
dict_values([4, '5', 'f'])
> D2.items() #모든 key, value 쌍
dict_items([('d', 4), ('e', '5'), (6, 'f')])
data에 해당 원소가 있는지를 반환하는 in
python에서 in을 이용하면 데이터에 특정 원소가 있는지 없는지를 T/F로 반환하여 출력합니다. 특정 원소 in data 형식으로 사용하고, list, tuple, set, dictionary에서 사용 가능하며 dictionary에서는 특정 key값 뿐 아니라 values() 함수를 이용해 특정 value가 있는지도 판단할 수 있습니다.
> print(L, '1' in L, 1 in L, 1 in L[1:]) #list에 있는 원소면 T, 없으면 F
[1, 2, 3, 4] False True False
> print(t, '1' in t, 1 in t) #tuple에 있는 원소면 T, 없으면 F
(1, 2, 3, 4, 5) False True
> print(s1, '1' in s1, 1 in s1) #set에 있는 원소면 T, 없으면 F
{1, 2, 3, 4, 5} False True
> "a" in D2, 'z' in D2 #dictionary에 있는 key면 T, 없으면 F
(True, False)
> '1' in D2.values(), "99" in D2.values()
(True, False)
5. data type5: String(str, 문자형)
python의 string 데이터 타입은 문자열을 말하며 '' 또는 ""를 이용해 생성할 수 있습니다. 문자열에 엔터(\n) 또는 탭(\t)을 포함하여 생성할 수 있는데, 스트링이 할당된 변수만 쓰고 실행하면 한 줄로 \n를 포함하여 출력하고, print() 함수를 이용하여 변수를 출력하면 엔터를 친 상태로 출력됩니다.
> fruits='apple \n orange \n banana'
> fruits
'apple \n orange \n banana'
> print(fruits)
apple
orange
banana
문자열(string)의 인덱싱(Indexing), 슬라이싱(Slicing), 합치기
string도 마찬가지로 인덱싱과 슬라이싱이 가능합니다. 입력한 스트링의 글자별로 하나의 원소로 보고, 첫번째 원소를 0번째, 마지막 원소를 -1번째로 하여 인덱싱, 슬라이싱을 합니다. +기호를 이용하여 string끼리 합칠 수 있으며, *n을 이용하여 특정 횟수(n)만큼 반복하여 string을 출력할 수 있습니다.
> a='123456-78910ab'
> print(a[0], a[-1]) #인덱싱
1 b
> print(a[:6], a[1::2]) #슬라이싱
123456 246790b
> print(a[:7]+'*******') #string 합치기
123456-*******
> a[:6]+a[7:] #6번째 문자(-) 제거
'12345678910ab'
문자열(string) 바꾸기, 쪼개기
replace('a', 'b') 함수를 이용하면 'a' 문자열을 'b' 문자열로 변경할 수 있습니다. split()함수를 이용하여 string을 쪼갤 수 있는데, 옵션을 주지 않고 string()으로 실행하면 공백을 기준으로 문자열을 나누고, 함수 안에 '특정 문자'를 넣으면 특정 문자를 기준으로 쪼개어 반환합니다. 이때, 문자열을 쪼개서 반환한 결과는 list 형태입니다.
> aaa='a b c'
> bbb="a, b, c"
> ccc='abc'
> print( aaa.split(), bbb.split(','), ccc.split())
['a', 'b', 'c'] ['a', ' b', ' c'] ['abc']
6. 5가지 데이터 타입끼리 변환하는 방법
앞에서 설명한 5가지 데이터 타입(list, tuple, set, dictionary, string)을 다른 데이터 타입으로 변환해보겠습니다.
> L=[1,2,3]
> t=(1,2,3)
> s={1,2,3}
> d={'a':1, 'b':2, 'c':3}
> a='123'
> print( type(L),type(t), type(s), type(d), type(a) )
<class 'list'> <class 'tuple'> <class 'set'> <class 'dict'> <class 'str'>
tuple, set, dictionary, string을 list로 변환하기 in python
list() 함수를 이용하여 다른 data type을 list 형태로 변환할 수 있습니다. list() 함수에 그냥 dictionary만 넣으면 dictionary의 key값만 리스트로 변환하고, d.values()를 넣으면 dictionary의 value값을 list로 변환할 수 있습니다. string을 list로 변환하면 한 글자가 하나의 원소로 끊겨서 변환됩니다.
> list(L) #list를 list로 변환
[1, 2, 3]
> list(t) #tuple을 list로 변환
[1, 2, 3]
> list(s) #set을 list로 변환
[1, 2, 3]
> list(d) #dictionary의 key를 list로 변환
['a', 'b', 'c']
> list(d.values()) #dictionary의 value를 list로 변환
[1, 2, 3]
> list(a) #string을 list로 변환
['1', '2', '3']
list, set, dictionary, string을 tuple로 변환하기 in python
list와 마찬가지로, tuple() 함수를 이용하여 다른 data type을 tuple 형태로 변환할 수 있으며, dictionary는 key만, string은 한 글자씩 끊겨서 tuple로 변환됩니다.
> tuple(L) #list를 tuple로 변환
(1, 2, 3)
> tuple(s) #set을 tuple로 변환
(1, 2, 3)
> tuple(d) #dictionary의 key를 tuple로 변환
('a', 'b', 'c')
> tuple(d.values()) #dictionary의 value를 tuple로 변환
(1, 2, 3)
> tuple(a)) #string을 tuple로 변환
('1', '2', '3')
list, tuple, dictionary, string을 set으로 변환하기 in python
set도 마찬가지로, set() 함수를 이용하여 다른 data type을 set 형태로 변환할 수 있으며, dictionary는 key만, string은 한 글자씩 끊겨서 변환됩니다. 집합의 성질에 의해 set으로 변환시 중복된 원소는 제거한 후 변환합니다.
> set(L) #list를 set으로 변환
{1, 2, 3}
> set(t) #tuple을 set으로 변환
{1, 2, 3}
> set(d) #dictionary의 key를 set으로 변환
{'a', 'c', 'b'}
> set(d.values()) #dictionary의 value를 set으로 변환
{1, 2, 3}
>set(a) #string을 set으로 변환
{'1', '2', '3'}
list, tuple, set을 dictionary로 변환하기 in python
다른 data type을 dictionary 형태로 변환하기 위해 dict() 함수를 이용하는데, dictionary는 key와 value로 이루어져 있으므로 zip() 함수를 같이 이용해야 합니다. 대응되는 순서쌍을 만들어야 하므로 서로 길이가 같은 2개의 data를 준비한 후, dict(zip()) 함수에 key, value 순서대로 data를 넣으면 dictionary로 변환할 수 있습니다. 이때, 2개의 data는 list, tuple, set, dictionary 모두 가능하며 데이터 타입이 달라도 됩니다. dictionary를 넣는 경우 key값이 변환됩니다.
> LL=['a', 'b', 'c']
> print(dict(zip(LL, L)), dict(zip(L, LL))) #list를 dict로 #key, value 순
{'a': 1, 'b': 2, 'c': 3} {1: 'a', 2: 'b', 3: 'c'}
> dict(zip(L,t)) #list, tuple을 dict로
{1: 1, 2: 2, 3: 3}
> dict(zip(L,s)) #list, set을 dict로
{1: 1, 2: 2, 3: 3}
> dict(zip(L,d))) #list, dict의 key를 dict로
{1: 'a', 2: 'b', 3: 'c'}
순서쌍을 원소로 가지는 tuple의 경우, dict() 함수를 이용하면 각 순서쌍의 첫번째 원소를 key, 두번째 원소를 value로 하여 dictionary로 변환합니다. list도 마찬가지로 가능합니다.
> tt=(('a',1),('b',2),('c',3))
> dict(tt)
{'a': 1, 'b': 2, 'c': 3}
list, tuple, set, dictionary를 string으로 변환하기 in python
str() 함수를 이용하여 list, tuple, set, dictionary 형태의 data를 string 형태로 변환할 수 있는데, 원래의 형태 그대로 변환됩니다.
> str(L) #list를 string으로 변환
'[1, 2, 3]'
> str(t) #tuple을 string으로 변환
'(1, 2, 3)'
> str(s) #set을 string으로 변환
'{1, 2, 3}'
> str(d) #dict를 string으로 변환
'{'a': 1, 'b': 2, 'c': 3}'
> str(d.values()) #dict의 value를 string으로 변환
'dict_values([1, 2, 3])'
string 형태의원소들 가지는 리스트에서, 모든 원소를 붙여서 하나의 string으로 변환하려면 join()함수를 이용합니다. list뿐 아니라 tupel, set도 가능합니다.
> dd=['a','b','c']
> "".join(dd)
'abc'
'데이터분석 > Python' 카테고리의 다른 글
| [머신러닝]나이브 베이즈 모델(Naïve bayes clasification) in python (0) | 2022.03.10 |
|---|---|
| [범주형 자료분석]다중 로지스틱 회귀분석 예제- Personal Loan data - (1) in python (0) | 2022.03.08 |
| [회귀분석]단순선형회귀분석(Simple Linear Regression) 예제-보스턴 주택 가격 예측 in python (0) | 2022.02.24 |
