Python 컬렉션 타입

경기도 인공지능 개발 과정/Python

Python 컬렉션 타입

agingcurve 2022. 5. 28. 14:41

학습목표

list, tuple에 대해 이해하고 사용할 수 있다.

리스트와 튜플

복수개의 값을 담을 수 있는 데이터 구조이다.
실생활에서 사용하는 리스트와 동일한 의미로 이해하면 된다. ex)수강생리스트 등.
list - mutable (생성된 후에 변경 가능)
tuple - immutable (생성된 후에 변경 불가능)

리스트 초기화

[] 안에 값을 담아서 생성한다.
list() 함수로 생성한다.
str.split()함수로 생성한다.
```
리스트 = []
리스트 = list()
```
##### 빈리스트 만들기

In [1]:

a = []

type(a)

Out[1]:

list

In [2]:

a = list()
type(a)

Out[2]:

list

In [3]:

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

[1, 2, 3, 4, 5, 6]

In [5]:

a = ['a',11,False]
a

Out[5]:

['a', 11, False]

In [7]:

b = [a, 'aa',20]
b

Out[7]:

[['a', 11, False], 'aa', 20]

list() 함수
- 다른 데이터 타입을 리스트로 변환할 때도 사용한다.

In [14]:

name = 'kang'
name_list = list(name)
name_list

number = '20'
print(type(number))
print(type(int(number)))

tu = (1,2,3,4)
print(type(tu))
tu = list(tu)
print(type(tu))

<class 'str'>
<class 'int'>
<class 'tuple'>
<class 'list'>

string split 함수
- 구분자로 구분되는 리스트를 반환한다.

In [15]:

s_list = 'hello test carami hahha'.split()
type(s_list)

Out[15]:

list

리스트 indexing

문자열의 인덱싱과 동일하게 동작한다.
[] 연산자를 이용하여 항목 얻어오기
[i] - i번째 원소를 반환
i가 음수인 경우도 가능하며 마지막원소가 -1로 하여 앞으로 갈때마다 1씩 감소함

In [18]:

a_list = [1,2,3,4,5,6]

print(a_list[0])
print(a_list[-1])

1
6

리스트 개별 아이템에 접근

인덱스에 접근하여 값을 업데이트 가능

In [27]:

a_str = 'hello python!!'

b_list = list(a_str)
print(b_list)

print(b_list[4])

b_list[4] = 'a'
print(b_list)
print(a_str[4])
# a_str[4]='a'

b = 'ppp'+a_str[3:]
print(b)

aa = 'test '+'python'
print(aa)

['h', 'e', 'l', 'l', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n', '!', '!']
o
['h', 'e', 'l', 'l', 'a', ' ', 'p', 'y', 't', 'h', 'o', 'n', '!', '!']
o
ppplo python!!
test python

In [28]:

a_list2 = [1,2,3,4]
a_list2[0] = 100
print(a_list2)

[100, 2, 3, 4]

리스트 slicing

문자열 슬라이싱과 동일하게 동작한다.
슬라이싱의 결과 역시 list 이다.

In [34]:

a_list = [1,2,3,4,5,6,7]

print(a_list[2:])
print(a_list[2:-1])
print(a_list[2:7])
print(a_list[::-1])
print(a_list[::2])

[3, 4, 5, 6, 7]
[3, 4, 5, 6]
[3, 4, 5, 6, 7]
[7, 6, 5, 4, 3, 2, 1]
[1, 3, 5, 7]

list 멤버 함수

append()
- 리스트의 끝에 항목을 추가한다.

In [35]:

a_list.append(8)

In [36]:

print(a_list)

[1, 2, 3, 4, 5, 6, 7, 8]

In [37]:

a_list.append([9,10])
print(a_list)

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

extend()
- 리스트를 연장한다.
- += 로도 가능하다.

In [39]:

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

[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7, 8]

In [40]:

a = [1,2,3]
b = [4,5,6]
a+=b  #a = a+b
print(a)

[1, 2, 3, 4, 5, 6]

In [41]:

print(a+b)

[1, 2, 3, 4, 5, 6, 4, 5, 6]

insert()로 항목추가
- 리스트의 원하는 위치에 추가 가능하다.
- 앞에 인덱스를, 뒤에 아이템을 명시한다.

In [57]:

a = [1,2,3]
b = [4,5,6]

a.insert(2,0)
print(a)
a.insert(-2,0)
print(a)
a.remove(0)
print(a)

[1, 2, 0, 3]
[1, 2, 0, 0, 3]
[1, 2, 0, 3]

remove()
- 값으로 항목 삭제한다.

In [60]:

a = [1,2,3]
print(a)

print(a.remove(3))
print(a)

[1, 2, 3]
None
[1, 2]

In [59]:

a = [1,2,3]
del a[0]
print(a)
del a 
print(a)

[2, 3]

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Input In [59], in <cell line: 5>()
      3 print(a)
      4 del a 
----> 5 print(a)

NameError: name 'a' is not defined

pop()
- 지우고자 하는 아이템을 반환 후, 삭제한다.

In [61]:

a = [1,2,3,4]
print(a.pop(1))

index()
- 찾고자 하는 값의 인덱스 반환한다.

In [62]:

a=[1,2,3,4]
print(a.index(3))

In [63]:

print(a)

[1, 2, 3, 4]

in 키워드
- 리스트 내에 해당 값이 존재하는지 확인한다.
- value in [list]
- True, False 중 한가지로 반환한다.

In [64]:

Out[64]:

[1, 2, 3, 4]

In [65]:

2 in a

Out[65]:

True

In [67]:

'a' in a

Out[67]:

False

In [68]:

100 in a

Out[68]:

False

list 정렬
- sort() -> 리스트 자체를 내부적으로 정렬한다.
- sorted() -> 리스트의 정렬된 복사본을 반환한다.

In [70]:

a = [33,12,5,77,34.66]

a.sort()
print(a)

a.sort(reverse=True)
print(a)

[5, 12, 33, 34.66, 77]
[77, 34.66, 33, 12, 5]

In [73]:

a = [33,12,5,77,34.66]

new_a = sorted(a)
print(a)
print(new_a)

[33, 12, 5, 77, 34.66]
[5, 12, 33, 34.66, 77]

range를 사용하여 리스트 만들기
- range(횟수)
- 리스트 = list(range(횟수))
- 리스트 = list(range(시작, 끝))
- 리스트 = list(range(시작, 끝, 증가폭))

In [74]:

range(5)

Out[74]:

range(0, 5)

In [75]:

list(range(5))

Out[75]:

[0, 1, 2, 3, 4]

In [76]:

list_100 = list(range(1,101))
print(list_100)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

In [77]:

list(range(1,10,2))

Out[77]:

[1, 3, 5, 7, 9]

In [78]:

list(range(-10,10,2))

Out[78]:

[-10, -8, -6, -4, -2, 0, 2, 4, 6, 8]

tuple

리스트와 같이 복수개의 값을 갖는 컬렉션 타입이다.
생성된 후 변경이 불가능하다.
읽기전용 리스트이다.

튜플 = (값,값,값)
튜플 = 값, 값, 값
튜플 = (값,) - 요소가 하나일 때 튜플로 지정하려면 , 를 붙혀준다.
튜플 = 값,

In [79]:

s = tuple()
type(s)

Out[79]:

tuple

In [80]:

t1 = ()
type(t1)

Out[80]:

tuple

In [81]:

t2 = (1,2,3)
print(t2)
print(type(t2))

(1, 2, 3)
<class 'tuple'>

In [85]:

t3 = (3,)
print(type(t3))

<class 'tuple'>

In [87]:

t4 = 1,2,3
print(t4)
print(type(t4))

(1, 2, 3)
<class 'tuple'>

In [89]:

t5 = 1,
type(t5)

Out[89]:

tuple

In [90]:

# range를 이용하여 tuple만들기 - 리스트와 동일하다. 
t6 = tuple(range(3))
print(t6)

(0, 1, 2)

In [3]:

# 요소가 한개인 튜플은 어떻게 만들까??    값뒤에 , 붙혀줌.

튜플을 리스트로 리스트를 튜플로 만들기

In [91]:

list_a = [1,2,3]
tuple_a = tuple(list_a)
print(tuple_a)

(1, 2, 3)

In [92]:

list_b = list(tuple_a)

In [93]:

print(list_b)

[1, 2, 3]

list unpacking, tuple unpacking

리스트나 튜플의 값을 차례대로 변수에 대입한다.
x = [1, 2, 3] a, b, c = x y = (4, 5, 6) d, e, f = y

list packing, tuple packing

변수에 리스트나 튜플을 할당하는 과정을 뜻한다.
a = [1,2,3]
a = (1,2,3)
a = 1,2,3

In [94]:

x = [1, 2, 3]
a, b, c = x
print(a,b,c)

1 2 3

In [ ]:

연습문제 a와 b의 값을 교환하시오

In [ ]:

a = 5
b = 4

print(a, b)

#여기에 구현
# tmp = a
# a = b
# b = tmp

a, b = b, a



print(a, b)

시퀀스 자료형

값이 연속적으로 이어져 있는 자료형을 말한다.
리스트, 튜플, range, 문자열 등이 시퀀스 자료형에 해당한다.

시퀀스객체안에 원하는 값 확인하기

값이 있는지 확인 할때는 아래와 같이 in 을 이용한다.
- 값 in 시퀀스 객체
in 앞에 not을 붙히면 반대로 값이 없는지 확인한다.
- 값 not in 시퀀스객체

In [99]:

t1 = (34,5,3,34,6)
print(3 in t1)

print(3 not in t1)
s = 'hello world!!'
print('h' in s)

print(5 in range(5))

print('c' in 'dkjfkdfjkd;safj')

True
False
True
False
False

시퀀스 객체 연결

- 연산자를 이용하여 객체를 서로 연결해서 새 객체를 만든다.
  - 시퀀스객체1 + 시퀀스객체2
단, range는 리스트나 튜플을 만든 후 연결해야 한다.
문자열은 + 연산자를 이용하여 문자열을 연결할 수 있다.

In [104]:

t1 = (1,2,3)
t2 = (4,5,6)
t3 = t1 + t2
print(t3)
print(t1)
print(t2)

(1, 2, 3, 4, 5, 6)
(1, 2, 3)
(4, 5, 6)

In [105]:

new_str = 'abc' + 'def'
print(new_str)

abcdef

In [5]:

# range(10) + range(11,5)   range 자체로 + 연산은 불가하다.
# range를 이용해서 리스트나 튜플 생성후 연결

In [112]:

tuple(range(10)) + tuple(range(11,15))

Out[112]:

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14)

시퀀스객체 반복하기

- 연산자를 이용하면 시퀀스 객체를 원하는 횟수만큼 반복할 수 있다.
0 또는 음수를 곱하면 빈 객체가 나온다. 실수는 곱할 수 없다.
- 시퀀스객체 * 정수
- 정수 * 시퀀스객체
range는 * 연산자를 사용할 수 없다.
문자열은 * 연산자 사용이 가능하다.

In [108]:

'hi' * 3

Out[108]:

'hihihi'

In [109]:

[1,2,3] * 3

Out[109]:

[1, 2, 3, 1, 2, 3, 1, 2, 3]

len() 함수 이용해서 개수 구하기

len(리스트)
len(튜플)
len(문자열)
len(range())

In [110]:

len(new_str)

Out[110]:

In [111]:

len('tekst dkfdkf dkjfdkfj')

Out[111]:

-------------------------------------------------------------------------

Dictionary

학습목표

dictionary, set에 대해 이해하고 활용할 수 있다.

dictionary

키와 값을 갖는 데이터 구조이다.
키는 내부적으로 hash값으로 저장된다.
순서가 없다. 그러므로 인덱스가 존재하지 않는다.
Key와 Value의 쌍 여러 개가 { }로 둘러싸여 있다.
각각의 요소는 Key : Value 형태로 이루어져 있고 쉼표(,)로 구분되어 있다.
dict = {} dic22 = {key1:value1, key2:value2,....}

In [1]:

d1 = {} 
type(d1)

Out[1]:

dict

In [2]:

person = {'name':'kang','age':20,'phone':'010-111-1111'}
print(person)

{'name': 'kang', 'age': 20, 'phone': '010-111-1111'}

In [3]:

print(person['name'])

kang

In [ ]:

d2 = {1:'kang'}
d3 = {'a':[1,2,3]}

딕셔너리 요소 추가 및 변경
- 기존에 키가 존재 하면, 새로운 값으로 업데이트된다.
- 존재하지 않으면, 새로운 키, 값 생성된다.

In [7]:

d4 = {1:'a'}
d4[1]
d4[2] = 'b'
print(d4)
d4[1]='aa'
print(d4)

{1: 'a', 2: 'b'}
{1: 'aa', 2: 'b'}

In [8]:

list_a = [1,1,1,1,]
print(list_a)

[1, 1, 1, 1]

In [9]:

print(d4)

{1: 'aa', 2: 'b'}

In [11]:

d4['name'] = 'knag'
print(d4)

{1: 'aa', 2: 'b', 'nmae': 'knag', 'name': 'knag'}

In [12]:

d4[3]='aa'
d4[4]='aa'

print(d4)

{1: 'aa', 2: 'b', 'nmae': 'knag', 'name': 'knag', 3: 'aa', 4: 'aa'}

딕셔너리 요소 삭제
- del 키워드
  - del a[1]
- pop() 함수
  - a.pop('key')

In [13]:

del d4['nmae']

In [14]:

print(d4)

{1: 'aa', 2: 'b', 'name': 'knag', 3: 'aa', 4: 'aa'}

In [16]:

d4.pop(1)

Out[16]:

'aa'

In [17]:

print(d4)

{2: 'b', 'name': 'knag', 3: 'aa', 4: 'aa'}

In [22]:

#setdefault()  이용해서 추가하기!! 
d4.setdefault(1)
print(d4)
d4.setdefault('5',100)
print(d4)
d4.setdefault('5',1000)
print(d4)

{2: 'b', 'name': 'knag', 3: 'aa', 4: 'aa', 1: None, '5': 100}
{2: 'b', 'name': 'knag', 3: 'aa', 4: 'aa', 1: None, '5': 100}
{2: 'b', 'name': 'knag', 3: 'aa', 4: 'aa', 1: None, '5': 100}

update()
- 두 딕셔너리를 병합한다.
- 겹치는 키가 있다면 parameter로 전달되는 키 값이 overwrite된다.

In [23]:

d4.update({'5':1000})
print(d4)

{2: 'b', 'name': 'knag', 3: 'aa', 4: 'aa', 1: None, '5': 1000}

In [27]:

x={'a':10,'b':20,'c':30,'d':40}

x.update(a=1000,b=2000)
print(x)

{'a': 1000, 'b': 2000, 'c': 30, 'd': 40}

In [29]:

y={1:'one',2:'two'}
y.update([[2,'TWO']])
print(y)

y.update([[2,'TWO'],[3,'three']])
print(y)

{1: 'one', 2: 'TWO'}
{1: 'one', 2: 'TWO', 3: 'three'}

In [ ]:

key삭제
- del 키워드 사용
- pop 함수 이용

In [30]:

print(y)

{1: 'one', 2: 'TWO', 3: 'three'}

In [31]:

del y[3]
print(y)

{1: 'one', 2: 'TWO'}

In [34]:

y.pop(1)

Out[34]:

'one'

In [35]:

x={'a':10,'b':20,'c':30,'d':40}

print(x.popitem())
print(x)

('d', 40)
{'a': 10, 'b': 20, 'c': 30}

clear()
- 딕셔너리의 모든 키-값 쌍을 삭제한다.

In [37]:

print(x)

x.clear()

print(x)

{'a': 10, 'b': 20, 'c': 30}
{}

in
- key값 존재여부를 확인한다.
- O(1) 연산 - 딕셔너리의 크기와 관계없이 항상 연산의 속도가 일정하다는 의미한다.

In [39]:

x={'a':10,'b':20,'c':30,'d':40}
print('a' in x)
print(1 in x)

True
False

value access
- dict[key]로 접급, 키가 없는 경우 에러 발생
- .get() 함수로 접근, 키가 없는 경우 None반환

In [41]:

x={'a':10,'b':20,'c':30,'d':40}
print(x.get('a'))
print(x.get('f'))

10
None

In [ ]:

모든 keys, values 접근

keys() - 키만 반환
values() - 값만 반환
items() - 키, 값의 튜플을 반환

In [ ]:

In [44]:

x={'a':10,'b':20,'c':30,'d':40}

print(list(x.keys()))

['a', 'b', 'c', 'd']

In [45]:

x.values()

Out[45]:

dict_values([10, 20, 30, 40])

In [47]:

list(x.items())

Out[47]:

[('a', 10), ('b', 20), ('c', 30), ('d', 40)]

리스트와 튜플로 딕셔너리 만들기

In [48]:

keys_list = ['a','b','c','d']

d1 = dict.fromkeys(keys_list)
print(d1)

{'a': None, 'b': None, 'c': None, 'd': None}

In [49]:

d2 = dict.fromkeys(keys_list,100)
print(d2)

{'a': 100, 'b': 100, 'c': 100, 'd': 100}

In [50]:

d3 = dict.fromkeys(keys_list,[10,20,30,40])
print(d3)

{'a': [10, 20, 30, 40], 'b': [10, 20, 30, 40], 'c': [10, 20, 30, 40], 'd': [10, 20, 30, 40]}

In [51]:

d4 = dict([('a', 10), ('b', 20), ('c', 30), ('d', 40)])
print(d4)

{'a': 10, 'b': 20, 'c': 30, 'd': 40}

In [53]:

d5 = dict(a='aa',v='bb',c='cc')
print(d5)

{'a': 'aa', 'v': 'bb', 'c': 'cc'}

set

dictionary에서 key만 활용하는 데이터 구조이다.
수학에서의 집합과 동일한 개념이다.
파이썬 2.3부터 지원된 자료형으로 집합에 관련된 것을 쉽게 처리한다.
set 키워드를 이용해서 만들 수 있다.
빈 set 을 만드는 방법은 set() 을 이용한다.
특징
- 중복을 허용하지 않는다.
- 순서가 없다.

In [56]:

a = set([1,2,4])
print(a)
type(a)

{1, 2, 4}

Out[56]:

set

set()으로 집합으로 변환

In [57]:

s1 = set('hello')
print(s1)

{'e', 'l', 'o', 'h'}

In [60]:

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

print(set(a))

[1, 1, 2, 2, 3, 4, 5, 5, 6, 7]
{1, 2, 3, 4, 5, 6, 7}

set operations
- 수학 연산과 동일하다.
- 교집합, 합집합, 차집합 등 지원한다.

In [63]:

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

print(a.union(b))
print(a.intersection(b))
print(a.difference(b))

{1, 2, 3, 4}
{2, 3}
{1}

In [65]:

print(a & b)
print(a | b)
print(a - b)

{2, 3}
{1, 2, 3, 4}
{1}

set 값 추가 제거 하기

In [66]:

s1 = {1,2,3}
s1.add(4)
print(s1)

{1, 2, 3, 4}

In [70]:

s1.update([4,5,6])
print(s1)

{1, 2, 3, 4, 5, 6}

In [73]:

s1.remove(2)
print(s1)

{3, 4, 5, 6}

In [74]:

s1.pop()

Out[74]:

'경기도 인공지능 개발 과정 > Python' 카테고리의 다른 글

Python 파일 입출력 (0)	2022.05.28
Python 함수, lambda 함수 (0)	2022.05.28
Python 조건문과 반복문(While, For) (0)	2022.05.28
Python 변수의 이해 및 기본 데이터 타입, 문자열 타입 이해 (0)	2022.05.28
Python 주피터 노트북 사용법 (0)	2022.05.28

현재글Python 컬렉션 타입

사회복지사로 3년 간 근무 하고, 개발자로 전향하면서 배웠던 내용을 정리하는 블로그 입니다.

C#, C# 디자인패턴, Flask, yolov8, 디자인패턴, docker, 코테준비, 딥러닝, 텐서플로, Python, 파이썬, SQL, 제이펍, YOLO, 프로그래머스, 딥러닝 기초, 코테, 파이썬 백엔드, LLM, yolov5,

Today :
Yesterday :

데이터시럽