Del Statement
a = [1,2,3,4,5]
del a[0]
print(a)
>>> [2, 3, 4, 5]
# del statement를 사용하면 리스트 내의 원소를 없앨 수 있다.
# list.remove(element)는 list내의 arg로 받은 element와 같은 값인 가장 맨 앞의 원소를 지운다.
# del은 위치를 지정하여 지울 수 있다.
a = [1,2,3,4,5]
del a[2:4]
print(a)
>>> [1, 2, 5]
# del a[start:end]는 start + 1 번 원소부터 end 번 원소까지 없앤다.
a = [1,2,3,4,5]
del a[:]
print(a)
>>> []
# 전체 범위를 지정하면 빈 리스트가 된다.
del a
print(a)
>>> Error
# 리스트 자체를 제거할 수도 있다.
Del statement는 리스트의 원소를 index를 지정하여 제거할 수 있다.
Sequence
string = 'Artyrie'
print(string[0])
>>> A
# string 자료형에서 인덱스로 각 알파벳을 부를 수 있는 것은 sequnce 자료형이기 때문이다.
----------------------
list = ['Artyrie', 'Python', 'Note']
print(list[0])
>>> Artyrie
----------------------
tuple = ('Artyrie', 'Python', 'Note')
print(tuple[0])
>>> Artyrie
Sequence 는 여러 객체(데이터)를 가지는 자료형으로, 각 객체(데이터)의 순서를 가지고 있다는 것이 특징이다.
Sequence에는 String, List, Tuple이 있다.
string = 'Artyrie'
list = ['Artyrie', 'Python', 'Note']
tuple = ('Artyrie', 'Python', 'Note')
해당 자료형들은 string에서 설명한 특징들 ( +* 연산, slice (s[ : ]), len()함수 등) 을 지니고 있다.
Tuple
a = (1,2,3,4,5)
print(a)
>>> (1, 2, 3, 4, 5)
# 튜플은 소괄호인 '(' ')'로 정의한다.
a = (1)
print(a)
>>> 1
# 튜플을 정의할 때 1개의 원소만 넣을 경우에는 a = (1)처럼 정의할 경우,
# 사칙연산의 우선순위를 나타내는 소괄호로 인식하여 1로 출력된다.
a = (1,)
print(a)
>>> (1,)
# 따라서 원소를 하나만 갖는 경우에는 쉼표를 뒤에 붙여주어야한다.
a = 1,2,3,4,5
print(a)
>>> (1, 2, 3, 4, 5)
# 튜플을 정의할 때, 소괄호가 없더라도 똑같이 적용된다.
----------------------
a = 1,2,3,4,5
a[0] = 5
>>> Error
# 튜플의 데이터는 변경할 수 없다.
----------------------
a = 1,2,3,4,5
del a[0]
>>> Error
# 튜플은 데이터를 변경할 수 없기에 제거또한 불가능하다.
a = 1,2,3,4,5
del a
print(a)
>>> Error
# del을 이용한 전체 제거는 가능하다.
# a 라는 변수 자체를 제거했기 때문에, 출력이 안된다.
----------------------
a = 1,2,3,4,5
print(a[2:4])
>>> (3, 4)
# 리스트와 마찬가지로 데이터 일부만을 호출하는 것은 가능하다.
print(a)
>>> (1, 2, 3, 4, 5)
# 그러나 내부 데이터가 변경되는 것은 아니다.
----------------------
Tuple은 list와 비슷하게 생긴 자료형으로, 사용법또한 비슷하다고 볼 수 있지만
가장 큰 차이점은 값을 변화시킬 수 있는지에 대한 여부이다.
위의 예처럼 튜플은 내부의 값을 변경할 수 없다.
튜플또한 리스트처럼
슬라이스 (t[start:end]), 덧셈 곱하기 연산, len() 함수 등을 이용할 수 있다.
Set
s = set([1,2,3])
print(s)
>>> {1, 2, 3}
# 집합 자료형은 set 키워드를 통해 만들 수 있다.
s = set('Artyrie')
>>> {'i', 'r', 't', 'A', 'y', 'e'}
# 스트링을 넣으면 자동으로 각 알파벳 별로 나뉘어 저장된다.
# 집합 자료형은 중복을 허용하지 않고 순서가 없기 때문에,
# 뒤죽박죽 섞인 것처럼 보이기도 한다.
# 매번 눈에 보이는 순서는 바뀐다.
! 숫자(int형 데이터)는 set에 바로 넣을 수 없다.
----------------------
s = set('Artyrie')
print(s[0])
>>> Error
# 집합에는 순서가 없기때문에 인덱싱으로 접근할 수 없다.
l = list(s)
l[0]
>>> r
# 집합에서 인덱싱을 통하여 저장된 값에 접근하려는 경우, 리스트나 튜플로 변환한 후 해야 한다.
----------------------
s1 = set([1,2,3,4,5,6])
s2 = set([4,5,6,7,8,9])
print(s1 & s2)
>>> {4, 5, 6}
# '&' 연산은 교집합으로, 집합의 교집합을 간단히 구할 수 있다.
# s1.intersection(s2) 와 같은 결과이다.
----------------------
s1 = set([1,2,3,4,5,6])
s2 = set([4,5,6,7,8,9])
print(s1 | s2)
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}
# '|' 연산은 합집합으로, 집합의 합집합을 간단히 구할 수 있다.
# s1.union(s2)와 같은 결과이다.
----------------------
s1 = set([1,2,3,4,5,6])
s2 = set([4,5,6,7,8,9])
print(s1 - s2)
>>> {1, 2, 3}
# '-' 연산은 차집합으로, 집합의 차집합을 간단히 구할 수 있다.
# s1.difference(s2) 와 같은 결과이다.
set은 말그대로 집합으로, 집합연산인 합집합, 교집합, 차집합 등을 수행할 수 있다.
Set의 메소드
s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6, 7, 8, 9])
print(s1.intersection(s2))
>>> {4, 5, 6}
# s1과 s2의 교집합을 구한다.
print(s1.union(s2))
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}
# s1과 s2의 합집합을 구한다.
print(s1.difference(s2))
>>> {1, 2, 3}
# s1과 s2의 차집합을 구한다.
----------------------
s1 = set([1, 2, 3])
s1.update([4, 5, 6])
print(s1)
>>> {1, 2, 3, 4, 5, 6}
# 집합은 update 메소드를 이용하여 값을 추가할 수 있다.
# set.update(arg) 는 arg를 set에 원소로 추가하는 것이다.
# extend의 개념이 적용된다.
----------------------
s1 = set([1, 2, 3])
s1.remove(3)
print(s1)
>>> {1, 2}
# 집합은 remove 메소드를 이용하여 특정한 값을 제거할 수 있다.
# set.remove(arg) 는 arg를 set에서 찾아 제거하는 것이다.
Set 메소드 정리
| 메소드 |
의미 |
| set1.intersection(set2) |
set1과 set2의 교집합을 구한다. # set1 & set2 |
| set1.union(set2) |
set1과 set2의 합집합을 구한다. # set1 | set2 |
| set1.difference(set2) |
set1과 set2의 차집합을 구한다. # set1 - set2 |
| set.update(arg) |
set에 arg로 받은 원소들을 추가한다. |
| set.remove(arg) |
set에서 arg인 값을 찾아 제거한다. |
Dictionaries
dic = {}
# dictionary 자료형으로 dic을 선언한다.
dic = dict()
# dictionary 자료형으로 dic을 선언한다.
----------------------
dic = {'key1': 'str', 'key2': 1}
dic['key3'] = True
print(dic)
>>> {'key1': 'str', 'key2': 1, 'key3': True}
# Dictionary는 key와 value 값을 1:1 매칭하여 저장하는 자료형이다.
# 위와 같이 value의 자료형 제한은 없다.
----------------------
dic = {'a' : 1, 'b' : 2}
print(dic[0])
>>> Error
# Dictionary는 순서 즉, index가 없으므로 index로 접근이 불가능하다.
print(dic['a'])
>>> 1
# 따라서 key값을 통하여 값에 접근해야 한다.
----------------------
dic = {'a' : 1, 'b' : 2}
dic['a'] = 3
print(dic)
>>> {'a': 3, 'b': 2}
# key값을 통하여 value값을 변경할 수 있다.
----------------------
dic = {'a' : 1, 'b' : 2}
del dic['a']
print(dic)
>>> {'b': 2}
# dictionary 자료형의 값은 del statement를 이용하여 제거해야한다.
Dictionary 자료형은 이름에 걸맞게 사전처럼 단어를 찾아 그 뜻을 확인하는 구조를 지녔다.
index를 숫자가 아닌 어떠한 값을 Key로써 지정하고 그 key에 값을 저장한다.
그래서 dic = { 'key' : value } 의 구조를 지닌다.
여기에는 각각의 다른 값이 들어갈 수 있다.
Dictionary와 관련된 함수
dic = {'a' : 1, 'b' : 2}
dic = list(dic)
print(dic)
>>> ['a', 'b']
# list 함수를 이용하면 dictionary 자료형을 list로 바로 변환할 수 있다.
# 값은 key값만 저장이 된다.
----------------------
dic = {'b' : 1, 'a' : 2}
>>> {'b': 1, 'a': 2}
dic = sorted(dic)
print(dic)
>>> ['a', 'b']
# sorted 함수를 사용하면 dic의 key값을 정렬한 list를 반환해준다.
----------------------
dic = dict([('a', 1), ('b', 2)])
print(dic)
>>> {'a': 1, 'b': 2}
# dict 함수를 이용하면 바로 키와 값을 할당하며 선언할 수 있다.
dic = dict(a=1, b=2)
print(dic)
>>> {'a': 1, 'b': 2}
# 동일한 방법이다.
Dictionary 관련 함수 정리
| 함수 |
의미 |
| list(dic) |
dic에서 key 값으로 구성된 list를 반환한다. |
| sorted(dic) |
dic에서 key 값을 정렬하여 list로 반환한다. |
| dict(arg) |
arg를 dictionary 자료형으로 만들어 반환한다. |
Dictionary의 메소드
dic = {'a': [1, 2, 3], 'b': 2}
dic2 = dic.copy()
print(dic2)
>>> {'a': [1, 2, 3], 'b': 2}
# dic2에 dic이 복사되었다.
dic2['c'] = 3
print(dic2)
>>> {'a': [1, 2, 3], 'b': 2, 'c': 3}
print(dic)
>>> {'a': [1, 2, 3], 'b': 2}
# dic2의 변화는 dic과 무관한 듯 보인다.
dic2['a'].append(4)
print(dic)
>>> {'a': [1, 2, 3, 4], 'b': 2}
print(dic2)
>>> {'a': [1, 2, 3, 4], 'b': 2, 'c': 3}
# 그러나 dic2에 있는 a의 value값인 list 자료형을 수정하니 dic의 값또한 수정이 된다.
-- PLUS --
dic = {'a': [1, 2, 3], 'b': 2}
dic2 = dict(dic)
dic2['a'].append(4)
print(dic)
>>> {'a': [1, 2, 3, 4], 'b': 2}
print(dic2)
>>> {'a': [1, 2, 3, 4], 'b': 2}
# dict()로 새로 선언을 한다고 한들 동일하게 변한다.
----------------------
import copy
# copy 라는 모듈을 사용한다고 선언한다.
dic = {'a': [1, 2, 3], 'b': 2}
dic2 = copy.deepcopy(dic)
# copy 모듈 안의 deepcopy 메소드를 통해 dic을 복사한다.
dic2['a'].append(4)
print(dic)
>>> {'a': [1, 2, 3], 'b': 2}
print(dic2)
>>> {'a': [1, 2, 3, 4], 'b': 2}
# deepcopy를 통해 dictionary를 복사한 결과, 내부 리스트를 수정해도 같이 변화하지 않는다.
# 즉, dictionary의 copy 메소드는 value값이 list 같은 자료형일 경우 메모리값을 복사한다.
# 그러므로 dic의 a값의 value 와 b값의 value는 같은 변수를 가르킬 것이다.
----------------------
dic = {'a': 1, 'b': 2, 'c': 3}
dic.update({'b': 4, 'a': 2})
print(dic)
>>> {'a': 2, 'b': 4, 'c': 3}
# dic의 update 메소드를 통해 여러 값을 한번에 수정할 수 있다.
Dictionary 메소드 정리
| 메소드 |
의미 |
| dic.copy() |
dic을 복사하여 반환한다. |
| dic.update(dic2) |
dic2값을 dic에 업데이트한다. #key가 없으면 추가한다. |
dic 안의 list형 value가 존재한다면, copy 모듈을 import 하여
copy.deepcopy(dic) 을 통하여 반환값 안의 list와 피복사 값 안의 list가
각각의 다른 주소값을 가진 list로 dic을 복사할 수 있다.
! 주의
해당 내용은 개인 정리를 위하여 작성한 내용으로, 틀린 내용이 존재할 수 있습니다.
잘못된 정보의 경우 댓글로 알려주시면 감사하겠습니다.
