[ AI 인공지능 ] ⑤ 반복가능객체

0. 반복가능객체(iterable)

• 반복이 가능한 친구들(요소가 여러개인 친구들)
• 문자열
• 리스트
• 튜플
• 세트
• 딕셔너리
• ...

1. 리스트

• 순서가 있다
• 중복된 값을 저장할 수 있다
• 수정 가능(mutable)

1-1. 리스트 생성하기

1.  list() 함수를 활용하기
2. [ ] 를 활용하기

a = [10, 15, 35, '안녕', 3.14]
type(a)
a

 

# 요소 조회
[ ] 인덱스 연산자를 활용한다

a[1] # 파이썬은 0번째부터
a[-1]

 

# 인덱스 슬라이싱

a[1:3]
a[1:3][1]

 

# 비어있는 리스트

요소가 0개인 리스트

li1 = []
type(li1)
li1 # []

li2 = list()
type(li2)
li2 # []

li3 = [1, '안녕', ['홍길동', '김철수'], 3.14]
li3[2] # ['홍길동', '김철수']
li3[2][1] # '김철수

scores = [80, 50, 60] # 국어, 영어, 수학
scores[1] = 100
scores
> [80, 100, 60]

li3[2][1] = '김영희'
li3
> [1, '안녕', ['홍길동', '김영희'], 3.14]

 

1-2. 리스트 함수와 메소드

len(반복가능객체) :  함수 사용 결과는 반복가능객체 속 요소의 개수(int가 결과)

len([10, 15, '안녕하세요'])
> 3

 

append(요소) : 리스트 마지막에 요소를 추가한다

                            : 함수 사용 결과가 값이 아니다(None)

li4 = []
li4

li4.append('배상엽')
print(li4)
li4.append('홍길동')
li4.append('홍길동')
li4.append('홍길동')
li4.append('박영희')
print(li4.append('박영희'))
print(li4)

 

insert(인덱스, 요소)

li4.insert(3, '안녕')
print(li4)

 

remove(요소) : 리스트에서 요소를 삭제해준다(가장 앞에 있는 요소)

li4.remove('홍길동')
# li4.remove('없는요소')
print(li4)

 

pop(인덱스) : 리스트에서 인덱스 위치의 요소를 삭제(기본은 마지막) 

                         : 함수 사용 결과가 삭제된 요소 값이다

li4.pop(0)
li4.pop() # 맨 뒤에를 삭제해줌
print(li4.pop())
> 안녕
print(li4)

 

del() : 변수를 삭제할 때 사용

name = '배상엽'
del(name)
# print(name)
name2 = '홍길동'
name = name2

print(li4)
del li4[2] # li4[2]방에 존재하는 값을 메모리에서 해제(삭제)
print(li4)
del li4[0:1]
print(li4)

 

count(요소) : 함수 사용 결과는 리스트 속에서 요소 개수(int)

li5 = [10, 20, 31, 10, 20, 10]

li5.count(10)

 

help(함수이름) : 괄호 안에 있는 함수의 설명을 보여준다

index(요소, 시작인덱스, 끝인덱스) : 리스트 안에서 요소의 치 인덱스를 찾는다

                                                                 : 시작인덱스 부터 끝인덱스 -1 사이에서

                                                                 : 시작인덱스와 끝인덱스 생략시 처음부터 끝까지

                                                                 : 함수 사용 결과는 찾은 요소의 위치 인덱스(int)

print(li5.index(20,2))
help(li5.index)

print(li5)
li5.reverse() #  역순으로 정렬해주는 함수
print(li5)

 

sort(key -= 정렬방식, reverse = True/False) 

기본은 오름차순 정렬

reverse True : 내림차순 정렬, key에 함수를 넘겨주면 함수가 적용된 상태로 정렬

li5.sort() # 오름차순으로 정렬해주는 함수
print(li5)
# sort -> str타입은 아스키코드로 정렬

li6 = ['appel', 'pineapple', 'grape', 'banana']
li6.sort(key = len)
print(li6)

# help(li6.sort)

li7 = [3, 9, 2]
li8 = sorted(li7) # 함수 사용 결과가 정렬된 list, 원본은 바꾸지 않는다
print(li7)
print(li8)

li7.sort()
print(li7)

 

extend(반복가능객체) : 원래 리스트에다가 괄호 안에 있는 반복가능객체를 합쳐준다

numbers = [23, 56, 15, 20]

numbers.extend([3, 5, 6, 7])
print(numbers)

numbers.extend('안녕하세요')
print(numbers)

 

1-3. 리스트(반복가능객체) 연산

'안녕' + '반가워'
[1, 5, 6] + [3, 7, 9] # 연산 결과는 하나의 리스트

'안녕' * 5
[1, 5, 6] * 2

li7 = [1, 2, 3]
print(li7 + [10, 20, 30])
print(li7)

> [1, 2, 3, 10, 20, 30]

> [1, 2, 3]

 

# 문자열, 리스트

# 사용자에게 이름과 겅을 입력받는다
# 이때 성이름 순으로 출력하시오
# 제약조건, 이름과 성 사이에는 띄어쓰기 한칸이 있다
# 입력예시
# 이름과 성 띄어쓰기로 입력 >> Kevin Brian
# 출력예사
# Brian Kevin

# 길동 홍
# 홍 길동

li = input('이름과 성 띄어쓰기로 입력 >> ').split()
print(li)
print(f'{li[1]} {li[0]}')

 

 

 

2. 반복가능객체의 형변환

• list(반복가능객체)

함수 사용 결과가 괄호 안에 있는 반복가능객체가 리스트로 변환된 결과

• tuple(반복가능객체)

함수 사용 결과가 괄호 안에 있는 반복가능객체가 tuple로 변환된 결과

list('안녕하세요')
tuple([10,20,20,30])

 

2-1. 여러개의 int값을 띄어쓰기로 입력받기

# 숫자 두 개를 입력받아서 두 수의 총합 구하기
nums = input('숫자 두 개를 띄어쓰기로 입력 >>').split()

# nums = ['10', '30']
print(f'결과 : {int(nums[0]) + int(nums[1])}')
print(nums)

 

nums = list(map(int, input('숫자 두개 >> ').split()))
print(nums)

 

map() 함수

map(함수, 반복가능객체)

map함수 사용 결과는 반복가능객체의 요소에 각각 함수를 적용시킨 map타입(반복가능객체)이다.

#  ['10', '20', '30'] --> [10,20,30]

map(int, ['10', '20', '30'])
list(map(int, ['10', '20', '30']))

# 예제 사이트
# http://www.jungol.co.kr/bbs/board.php?bo_table=pbank&sca=py

 

3. 튜플

• 순서가 존재한다
• 중복된 값을 저장할 수 있다
• 수정 불가능(immutable)

 

3-1. 튜플 생성 

1. tuple()
2. ( ) 를 사용

t = tuple()
type(t)
print(t)

t2 = ()
type(t2)
print(t2)

t3 = (10, 20, '안녕', (10, 100, 1000), ['안녕','반가워'])
print(t3)
len(t3)

# []인덱스 연산자 튜플 속에 있는 값 조회
t3[3]
t3[3][1]

# 수정 불가능
# t3[0] = '수정'

 

 

3-2. 튜플 메소드 

names = ('kim', 'park', 'choi')

# count(요소) : 요소의 개수를 return
# index(요소) : 요소의 위치 인덱스를 return

# 요소가 한 개 있는 튜플
# 최우선 연산자가 아닌 튜플을 알려주는 ㅇㄴ산자라는 것을 보여주기 위해서 
# , 를 써준다
t = (10)
type(t)

t = (10,)
type(t)
len(t)

# 튜플을 알려주는 소괄호는 생략이 가능하다
names = '배상엽', '김철수', '홍길동'
type(names)
print(names)

 

4. 언패킹

• 리스트 언패킹
• 튜플 언패킹

여러개의 변수를 동사에 만드는 방법

a = '배상엽'
b = 15

print(f'이름은 {a}이고, 나이는 {b}살입니다')

> 이름은 배상엽이고, 나이는 15살입니다

 

# 소괄호가 생략된 튜플이다

--> (a, b) = ('배상엽', 15)

# 튜플 언패킹(튜플을 풀어버리면서)이 일어나면서 각각의 변수에는 값이 대입되게 된다

a, b = '배상엽', 15

print(f'이름은 {a}, 나이는 {b}살')

> 이름은 배상엽, 나이는 15살

 

# 리스트 언패킹이 일어나면서 각각의 값이 변수에 순서대로 대입된다

name, age, height = ['김철수', 20, 180.5]

print(f'이름: {name}, 나이 : {age}, 키 : {height}')

> 이름 : 김철수, 나이 : 20, 키 : 180.5

 

5. 세트

• 중복된 값을 저장할 수 없다
• 순서가 없다(인덱스 번호 사용 불가)
• 수정가능(mutable)

5-1. 세트 생성

1. set() 함수 사용
2. 중괄호 { } 사용 

s1 = {'바나나', '사과', '오렌자', '바나나'}
type(s1)
print(s1) # 순서가 존재하지 않고, 중복된 값을 저장하지 않는다
# s1[1]

# 비어있는 세트를 만들 떄는 반그시 set() 함수를 사용해야 한다
s2 = set()
type(s2)
print(s2)

> {'바나나', '오렌지', '사과'}

> set()

 

5-2. 세트 관련 메소드

 

🔹요소 추가 

add(요소) : 괄호 안에 있는 요소를 세트에 추가한다

names = set()
names.add ('배상엽')
names.add ('김철수')
names.add ('홍길동')
names.add ('홍길동')
names.add ('홍길동')
print(names)

> {'배상엽', '홍길동', '김철수'}

 

pop() : 세트 속 요소 한개 삭제

            : 함수 사용 결과는 삭제된 요소(return)

print(names.pop())
print(names)

> 배상엽
> {'홍길동', '김철수'}

 

 remove(요소) : 세트 속에서 요소 삭제

                             : 없는 요소라면 오류

names.remove('김철수')
print(names)

> {'홍길동'}

 

discard(요소) : 세트 속에서 요소 삭제 

                            : 없는 요소라면 오류 안남

names.discard('박영희')
print(names)

> {'홍길동'}

 

6. 딕셔너리

• key와 value 한쌍(item)으로 저장하는 방법
• key (인덱스 대신 사용)는 중복 X, value는 중복 O
• 수정가능하다(mutable)

6-1. 딕셔너리 생성

1. dict() 함수 사용
2. { } 사용

di1 = {'국어' : 50, '영어' : 70, '수학' : 80}
print(di1)

> {'국어': 50, '영어': 70, '수학': 80}

 

len(반복가능객체) : 요소의 개수

len(di1) # 3, 요소의 개수 3개
> 3
di1['국어'] # 인덱스 번호 대신에 key값 사용
> 50

 

# 있는 key는 수정
di1['국어'] = 80
print(di1)
> {'국어': 80, '영어': 70, '수학': 80}

# di1['과학'] -> 없을 때는 오류남

# 앖는 key는 추가
di1['과학'] = 100
print(di1)
> {'국어': 80, '영어': 70, '수학': 80, '과학': 100}

 

6-2. 딕셔너리 관련 메소드

 

get(key) : 해당 key에 저장된 값이 함수 사용 결과가 된다

                  : 없는 key 사용해도 오류 안남

scores.get('국어')
> 50

 

pop(key) : 해당 key를 삭제

                    : 함수 사용 결과 삭제된 value 값

scores.pop('국어') 
> 50 
print(scores)
> {'수학': 70, '영어': 80}

 

popitem() : 딕셔너리의 마지막 요소 삭제

                      : 함수 사용 결과는 key와 value 한 쌍이 들어있는 tuple 타입이다

k, v = scores.popitem()
print(scores)
> {'수학': 70}

print(f'k:{k}, v:{v}')
> k:영어, v:80

scores['과학'] = 100
scores['사회'] = 20
print(scores)
> {'수학': 70, '과학': 100, '사회': 20}

 

keys() : 함수 사용 결과는 딕셔너리의 key값들이 들어있는 반복가능객체(dict_keys 타입)

scores.keys()
> dict_keys(['수학', '과학', '사회'])

list(scores.keys())
> ['수학', '과학', '사회']

 

values() : 함수 사용 결과는 딕셔너리의 value값들이 들어있는 반복가능객체(dict_values 타입)

scores.values()
> dict_values([70, 100, 20])

 

items() : 함수 사용 결과는 딕셔너리의 key와 value(item)이 한 쌍으로 묶여있는 

                  튜플들이 요소로 들어있는 반복가능객체(dict_items 타입)

scores.items()
> dict_items([('수학', 70), ('과학', 100), ('사회', 20)])

list(scores.items())
> [('수학', 70), ('과학', 100), ('사회', 20)]

 

6-3. 복잡한 딕셔너리 

• 치환, 치환, 치환하여 해석하자
• 결과가 무슨 타입인지가 중요하다

dictionary = {'id'      : 'abc123', 
              'pw'      : '0105',
              'scores'  : [50, 89, 64],
              'info'    : {'name' : '홍길동', 
                           'major' : '경영', 
                           'age' : 50}
              }

# 해당 dictinary 안에는 학생에 대한 정보가 들어있다
# 학생 이름과 학과, 나이를 출력하고
print(dictionary['info']['name'])
print(dictionary.get('info').get('major'))
print(dictionary['info'].get('age'))

> 홍길동
> 경영
> 50

# 나이를 20살로 수정한 뒤에
dictionary['info']['age'] = 20

# 다시 출력하기
print(dictionary)
> {'id': 'abc123', 'pw': '0105', 'scores': [50, 89, 64], 
  'info': {'name': '홍길동', 'major': '경영', 'age': 20}}

 

7. in / not in 연산자와 반복가능객체

• 요소 in 반복가능객체

요소가 반복가능객체 안에 포함되어 있다면 True 아니면 False

• 요소 not in 반복가능객체

요소가 반복가능객체 안에 포함되어있지 않다면 True 아니면 False

'ap' in 'apple' # True
'ap' not in 'apple' # False

10 in [1, 5, 10, 32] # True
[5, 10] not in [1, 5, 10, 32] # True

10 in (1, 5, 6) # False
10 not in (1, 5, 6) # True

s1 = {'배상엽', '홍길동', '김철수'}
'홍길동' in s1 # True
'홍길동' not in s1 # False

# 딕셔너리에서 판단 여부는 key 값이다
di = {'국어': 20, '영어': 70, '수학': 80}
20 in di # False
'국어' in di # True

# di 딕셔너리 안에 value값에 20이 포함되어 있다면 True 아니면 False가 나오게 작성
num = int(input('입력 >> '))
num in di.values()
# di.values() --> [20, 70, 80]