[3주차3,4일차] Chapter 04_자료구조/알고리즘 자료구조5~6

리스트나머지 기능들(1)

리스트 곱셈 연산

리스트를 곱셈 연산하면 아이템이 반복된다.

#문자일 때
students = ['홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은']
print('students: {}' .format(students))

studentsMul = students * 3
print('studentsMul: {}' .format(studentsMul))


#숫자일 때
numbers = [2, 50, 0.12, 1, 9]
print('numbers: {}' .format(numbers))

numbersMul = numbers * 2
print('numbersMul: {}' .format(numbersMul))

#결괏값:
students: ['홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은']
studentsMul: ['홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은', '홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은', '홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은']
numbers: [2, 50, 0.12, 1, 9]
numbersMul: [2, 50, 0.12, 1, 9, 2, 50, 0.12, 1, 9]

아이템 위치 찾기

index(item) 함수를 item의 인덱스를 알아낼 수 있다.

#문자일 때
students = ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
print('students: {}' .format(students))

searchIdx = students.index('강호동')
print('searchIdx: {}' .format(searchIdx)) # 인덱스로 어떤 아이템을 찾으면 가장 앞쪽에 있는 것 하나만 찾음!(뒤쪽에 있는 것은 찾지 않음.)

searchIdx = students.index('강호동', 2, 6)
print('searchIdx: {}' .format(searchIdx))


#숫자일 때
numbers = [2, 50, 0.12, 1, 9]
searchIdx2 = numbers.index(0.12)
print('searchIdx2: {}' .format(searchIdx2))

#결괏값:
students: ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
searchIdx: 1
searchIdx: 5
searchIdx2: 2

실습

1부터 10까지의 정수가 중복되지 않고 섞여 있을 때 행운의 숫자 7의 위치를 찾자!

import random

sampleList = random.sample(range(1, 11), 10) # 1에서 10까지 총 10개의 숫자를 중복되지 않게 색출

selectIdx = int(input('숫자 7의 위치 입력: '))
searchIdx = sampleList.index(7)

if searchIdx == selectIdx:
    print('빙고!!')
else:
    print('ㅜㅜ')

print('sampleList: {}' .format(sampleList))
print('searchIdx: {}' .format(searchIdx))

#결괏값:
숫자 7의 위치 입력: 6
ㅜㅜ
sampleList: [2, 10, 3, 1, 8, 6, 5, 9, 4, 7]
searchIdx: 9

리스트나머지 기능들(2)

특정 아이템의 개수 알아내기

count() 함수를 이용하면 특정 아이템의 개수를 알아낼 수 있다.

students = ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
print('students: {}' .format(students))

searchCnt = students.count('홍길동')
print('searchCnt: {}' .format(searchCnt))

searchCnt = students.count('강호동')
print('searchCnt: {}' .format(searchCnt))

searchCnt = students.count('김아무개')
print('searchCnt: {}' .format(searchCnt))

# 결괏값:
students: ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
searchCnt: 1
searchCnt: 2
searchCnt: 0

특정 아이템 삭제

del 키워드를 이용하면 특정 아이템을 삭제할 수 있다.

students = ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
print('students: {}' .format(students))

del students[1]
print('students: {}' .format(students))

del students[4]
print('students: {}' .format(students))

# slicing 기능을 사용해서 del(삭제)하기
students = ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
print('students: {}' .format(students))

del students[1:4]
print('students: {}' .format(students))


students = ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
print('students: {}' .format(students))

del students[2:]
print('students: {}' .format(students))

# 결괏값:
students: ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
students: ['홍길동', '박찬호', '이용규', '박승철', '강호동', '김지은']
students: ['홍길동', '박찬호', '이용규', '박승철', '김지은']
students: ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
students: ['홍길동', '박승철', '강호동', '김지은']
students: ['홍길동', '강호동', '박찬호', '이용규', '박승철', '강호동', '김지은']
students: ['홍길동', '강호동']

실습

하루 동안 헌혈을 진행한 후 혈액형 별 개수를 파악하는 프로그램을 만들어보자.

import random
types = ['A', 'B', 'AB', 'O']
todayData = []
typeCnt = []

for i in range(100):
    type = types[random.randrange(len(types))]
    todayData.append(type)

print('todayData: {}' .format(todayData))
print('todayData length: {}' .format(len(todayData)))

for type in types:
    print('{}형 \t : {}개' .format(type, todayData.count(type)))

# 결괏값:
todayData: ['B', 'AB', 'A', 'B', 'A', 'AB', 'AB', 'O', 'O', 'B', 'B', 'B', 'A', 'A', 'A', 'AB', 'AB', 'O', 'O', 'AB', 'A', 'B', 'O', 'A', 'A', 'O', 'B', 'A', 'AB', 'B', 'A', 'AB', 'AB', 'AB', 'A', 'O', 'O', 'B', 'AB', 'A', 'O', 'AB', 'AB', 'AB', 'B', 'O', 'O', 'AB', 'O', 'A', 'B', 'O', 'A', 'B', 'AB', 'AB', 'AB', 'O', 'A', 'B', 'B', 'AB', 'B', 'A', 'A', 'O', 'O', 'A', 'A', 'B', 'AB', 'AB', 'AB', 'A', 'B', 'B', 'O', 'AB', 'AB', 'A', 'AB', 'A', 'B', 'AB', 'B', 'AB', 'A', 'B', 'AB', 'A', 'A', 'AB', 'O', 'B', 'AB', 'AB', 'B', 'A', 'AB', 'AB']
todayData length: 100
A형 	 : 26개
B형 	 : 23개
AB형  : 33개
O형 	 : 18개

튜플(Tuple)

튜플(Tuple)이란?

리스트(List)와 비슷하지만 아이템 변경이 불가하다.

리스트와 튜플의 차이점

• 리스트: 아이템 변경(수정, 삭제 등) 가능
• 튜플 : 아인템 변경(수정, 삭제 등) 불가능

튜플 선언

'()'를 이용해서 선언하고, 데이터 구분은 ','를 이용한다.

# 문자열 튜플의 경우
students = ('홍길동', '박찬호', '이용규', '박승철', '김지은')
print('students: {}' .format(students))
print('students type: {}' .format(type(students)))

# 숫자 튜플의 경우
numbers = (10, 20, 30, 40, 50)
print('numbers: {}' .format(numbers))
print('numbers type: {}' .format(type(numbers)))

# 리스트의 경우
studentsList = ['홍길동', '박찬호', '이용규', '박승철', '김지은']
print('studentsList: {}' .format(studentsList))
print('students type: {}' .format(type(studentsList)))

#결괏값:
students: ('홍길동', '박찬호', '이용규', '박승철', '김지은')
students type: <class 'tuple'>
numbers: (10, 20, 30, 40, 50)
numbers type: <class 'tuple'>
studentsList: ['홍길동', '박찬호', '이용규', '박승철', '김지은']
students type: <class 'list'>

실습

가족 이름을 튜플에 저장하고 출력해보자.

myFamilyNames = ('홍아빠', '홍엄마', '홍길동', '홍동생')
print(myFamilyNames)

myFamilyNames[2] = '홍홍홍'

#결괏값:
('홍아빠', '홍엄마', '홍길동', '홍동생')
## 값 수정 시(두 번째 실행), 에러남.##
Traceback (most recent call last):
  File "C:\pythonEx\project\4_020\tuple.py", line 21, in <module>
    myFamilyNames[2] = '홍홍홍'
    ~~~~~~~~~~~~~^^^
TypeError: 'tuple' object does not support item assignment

오늘 일정을 튜플에 저장하고 출력해보자.

todaySchedule = ('10시-업무회의',
                 '12시-친구와점심약속',
                 '3시-자료정리',
                 '6시-운동',
                 '9시-TV시정')
print('todaySchedule : {}' .format(todaySchedule))

#결괏값:
todaySchedule : ('10시-업무회의', '12시-친구와점심약속', '3시-자료정리', '6시-운동', '9시-TV시정')

튜플 아이템 조회

인덱스

튜플도 리스트와 마찬가지로 아이템에 자동으로 부여되는 번호표가 있다.

아이템 조회

튜플 아이템은 인덱스를 이용해서 조회 가능하다.

students = ('홍길동', '박찬호', '이용규', '박승철', '김지은')

print('students[0]: {}' .format(students[0]))
print('students[1]: {}' .format(students[1]))
print('students[2]: {}' .format(students[2]))
print('students[3]: {}' .format(students[3]))
print('students[4]: {}' .format(students[4]))

#인덱스외의 값일 때, 오류남.
print('students[5]: {}' .format(students[5])) # 오류남

numbers = (10, 20, 30, 40, 50)
print('numbers[4]: {}' .format(numbers[4]))
print('numbers[3]: {}' .format(numbers[3]))
print('numbers[2]: {}' .format(numbers[2]))
print('numbers[1]: {}' .format(numbers[1]))
print('numbers[0]: {}' .format(numbers[0]))

# 결괏값:
students[0]: 홍길동
students[1]: 박찬호
students[2]: 이용규
students[3]: 박승철
students[4]: 김지은
##오류##
numbers[4]: 50
numbers[3]: 40
numbers[2]: 30
numbers[1]: 20
numbers[0]: 10

실습

5명의 학생 이름을 튜플에 저장하고 인덱스가 홀수인 학생과 짝수(0포함)인 학생을 구분해서 인덱스와 학생 이름을 출력해보자.

students = ('김성애', '신경도', '최승철', '황동석')
print('-- 인덱스가 짝수인 학생 --')
print('students[0]: {}' .format(students[0]))
print('students[2]: {}' .format(students[2]))
print('-- 인덱스가 홀수인 학생 --')
print('students[1]: {}' .format(students[1]))
print('students[3]: {}' .format(students[3]))

# 결괏값:
-- 인덱스가 짝수인 학생 --
students[0]: 김성애
students[2]: 최승철
-- 인덱스가 홀수인 학생 --
students[1]: 신경도
students[3]: 황동석

위의 출력 방법으로 for문으로 변경해보자.

students = ('김성애', '신경도', '최승철', '황동석')
for i in range(len(students)):
    if i % 2 == 0:
        print('인덱스가 짝수 : students[{}] : {}' .format(i, students[i]))
    else:
        print('인덱스가 홀수 : students[{}] : {}' .format(i, students[i]))

# 결괏값:
인덱스가 짝수 : students[0] : 김성애
인덱스가 홀수 : students[1] : 신경도
인덱스가 짝수 : students[2] : 최승철
인덱스가 홀수 : students[3] : 황동석

in과 not in 키워드

in, not in 키워드

in, not in 키워드를 이용하면 아이템의 존재 유/무를 알 수 있다.

studentsTuple = ('홍길동', '박찬호', '이용규', '박승철', '김지은')

searchName = input('학생 이름 입력: ')
if searchName in studentsTuple:
    print('{} 학생은 우리반 학생입니다.' .format(searchName))
else:
    print('{} 학생은 우리반 학생이 아닙니다.' .format(searchName))

# 결괏값:
학생 이름 입력: 박찬호
박찬호 학생은 우리반 학생입니다.

학생 이름 입력: 강호동
강호동 학생은 우리반 학생이 아닙니다.

아이템 조회

in, not in 키워드는 문자열에서도 사용 가능하다.

pythonStr = '파이썬(영어: Python)은 1991년 프로그래머인 귀도 반 로섬이 발표한 고급 프로그래밍 언어로, '\
            '플랫폼에 독립적으로 인터프리터식, 객체지향적, 동적 타이핑(dynamically typed) 대화형언어이다. '\
            '파이썬이라는 이름은 귀도가 좋아하는 코미디 <Monty Python\' s Flying Circus>에서 따온 것이다.'

print('{} : {}' .format('Python', 'Python' in pythonStr))  # True
print('{} : {}' .format('python', 'python' in pythonStr))  # False

print('{} : {}' .format('파이썬', '파이썬' in pythonStr))  # True
print('{} : {}' .format('파이선', '파이선' in pythonStr))  # False

print('{} : {}' .format('귀도', '귀도' in pythonStr))  # True
print('{} : {}' .format('객체지향적', '객체지향적' in pythonStr))  # True

# 결괏값:
Python : True
python : False
파이썬 : True
파이선 : False
귀도 : True
객체지향적 : True

실습1

컴퓨터가 1부터 10까지 5개의 난수를 생성한 후, 사요앚가 입력한 숫자가 있는지 또는 없는지 출력하는 프로그램을 만들어보자.

import random

randomNumbers = random.sample(range(1, 11), 5)

userNumber = int(input('숫자 입력(확율 50%): '))
if userNumber in randomNumbers:
    print('빙고!')
else:
    print('다음 기회에~')

print('randomNumbers: {}' .format(randomNumbers))
print('userNumbers: {}' .format(userNumber))

# 결괏값:
숫자 입력(확율 50%): 8
다음 기회에~
randomNumbers: [4, 3, 10, 1, 9]
userNumbers: 8

Process finished with exit code 0

실습2

문장에서 비속어가 있는지 알아내는 프로그램을 만들어보자.

wrongWord = ['쩔었다', '짭새', '꼽사리', '먹튀', '지린', '쪼개다', '뒷담 까다']
sentence = '짭새 등장에 강도들은 모두 쩔었다. 그리고 강도 들은 지린 듯 도망갔다.'

for word in wrongWord:
    if word in sentence:
        print('비속어: {}' .format(word))

# 결괏값:
비속어: 쩔었다
비속어: 짭새
비속어: 지린

튜플 길이

아이템 개수

리스트와 마찬가지로, 튜플에 저장된 아이템 개수를 튜플 길이라고 한다.

students = ('홍길동', '박찬호', '이용규', '박승철', '김지은')
sLength = len(students)
print('Length of students : {}' .format(sLength))

# 결괏값:
Length of students : 5

len()를 이용한 조회

len()과 반복문을 이용하면 튜플의 아이템 조회가 가능하다.

# for문 이용
students = ('홍길동', '박찬호', '이용규', '박승철', '김지은')
for i in range(len(students)):
    print('i : {}' .format(i))
    print('students[{}] : {}' .format(i, students[i]))

# 결괏값:
i : 0
students[0] : 홍길동
i : 1
students[1] : 박찬호
i : 2
students[2] : 이용규
i : 3
students[3] : 박승철
i : 4
students[4] : 김지은

# while문 이용
students = ('홍길동', '박찬호', '이용규', '박승철', '김지은')

n = 0
sLength = len(students)
while n < sLength:
    print('n : {}' .format(n))
    print('students[{}] : {}' .format(n, students[n]))
    n += 1

# 결괏값:
n : 0
students[0] : 홍길동
n : 1
students[1] : 박찬호
n : 2
students[2] : 이용규
n : 3
students[3] : 박승철
n : 4
students[4] : 김지은

실습

좋아하는 운동 종목을 튜플에 저장하고 반복문을 이용해서 출력해 보자.

myFavoriteSports = ('수영', '배구', '야구', '조깅')

for i in range(len(myFavoriteSports)):
    print('myFavoriteSports[{}]: {}' .format(i, myFavoriteSports[i]))

# 결괏값:
myFavoriteSports[0]: 수영
myFavoriteSports[1]: 배구
myFavoriteSports[2]: 야구
myFavoriteSports[3]: 조깅

튜플 결합

튜플 결합

두 개의 튜플을 결합할 수 있다.

studentTuple1 = ('홍길동', '박찬호', '이용규')
studentTuple2 = ('박승철', '김지은', '강호동')

studentTuple3 = studentTuple1 + studentTuple2
print('studentTuple3: {}' .format(studentTuple3))

# 결괏값:
studentTuple3: ('홍길동', '박찬호', '이용규', '박승철', '김지은', '강호동')

리스트 vs 튜플

리스트에서 사용할 수 있는 extend()함수를 튜플에서는 사용할 수 없다.

• 리스트일 때

studentList1 = ['홍길동', '박찬호', '이용규']
studentList2 = ['박승철', '김지은', '강호동']

studentList1.extend(studentList2)
print('studentList1: {}' .format(studentList1))

# 결괏값:
studentList1: ['홍길동', '박찬호', '이용규', '박승철', '김지은', '강호동']

• 튜플일 때

studentTuple1 = ('홍길동', '박찬호', '이용규')
studentTuple2 = ('박승철', '김지은', '강호동')

studentTuple1.extend(studentTuple2)
print('studentTuple1: {}' .format(studentTuple1))

# 결괏값:
오류남.

실습

튜플을 이용해서 나와 친구가 좋아하는 번호를 합치되 번호가 중복되지 않게 하는 프로그램을 만들자.

myFavoriteNumbers = (1, 3, 5, 6, 7)
friendFavoriteNumbers = (2, 3, 5, 8, 10)

print('myFavoriteNumbers: {}' .format(myFavoriteNumbers))
print('friendFavoriteNumbers: {}' .format(friendFavoriteNumbers))

for number in friendFavoriteNumbers:
    if number not in myFavoriteNumbers:
        myFavoriteNumbers = myFavoriteNumbers + (number, )

print('myFavoriteNumbers: {}' .format(myFavoriteNumbers))

# 결괏값:
myFavoriteNumbers: (1, 3, 5, 6, 7)
friendFavoriteNumbers: (2, 3, 5, 8, 10)
myFavoriteNumbers: (1, 3, 5, 6, 7, 2, 8, 10)

튜플 슬라이싱

튜플 슬라이싱

리스트와 마찬가지로 [n:m]을 이용하면 리스트에서 원하는 아이템만 뽑아낼 수 있다.

# 문자일 때
students = ('홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은')
print('students: {}' .format(students))
print('students[2:4]: {}' .format(students[2:4]))
print('students[:4]: {}' .format(students[:4]))
print('students[2:]: {}' .format(students[2:]))
print('students[2:-2]: {}' .format(students[2:-2]))
print('students[-5:-2]: {}' .format(students[-5:-2]))

# 숫자일 때
numbers = (2, 50, 0.12, 1, 9, 7, 17)
print('numbers: {}' .format(numbers))
print('numbers[2:4]: {}' .format(numbers[2:4]))
print('numbers[-5:-2]: {}' .format(numbers[-5:-2]))

# 결괏값:
students: ('홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은')
students[2:4]: ('이용규', '강호동')
students[:4]: ('홍길동', '박찬호', '이용규', '강호동')
students[2:]: ('이용규', '강호동', '박승철', '김지은')
students[2:-2]: ('이용규', '강호동')
students[-5:-2]: ('박찬호', '이용규', '강호동')
numbers: (2, 50, 0.12, 1, 9, 7, 17)
numbers[2:4]: (0.12, 1)
numbers[-5:-2]: (0.12, 1, 9)

슬라이싱 단계 설정

슬라이싱할 때 단계를 설정할 수 있다.

슬라이싱을 이용한 아이템 변경

튜플은 슬라이싱을 이용해서 아이템을 변경할 수 없다.
리스트에 튜플 아이템으로 변경 가능

students = ['홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은']
print('students: {}' .format(students))

students[1:4] = ('park chaho', 'lee younggyu', 'gang hodong')
print('students: {}' .format(students))
print(type(students))

# 결괏값:
students: ['홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은']
students: ['홍길동', 'park chaho', 'lee younggyu', 'gang hodong', '박승철', '김지은']
<class 'list'>

slice() 함수

slice()함수를 이용해서 아이템을 슬라이싱할 수 있다.

students = ('홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은')
print('students: {}' .format(students))

print('students[2:4]: {}' .format(students[slice(2,4)]))
print('students[2:4]: {}' .format(students[slice(4)]))
print('students[2:4]: {}' .format(students[slice(2, len(students))]))
print('students[2:4]: {}' .format(students[slice(2, len(students) - 2)]))
print('students[2:4]: {}' .format(students[slice(len(students) - 5, len(students) - 2)]))

# 결괏값:
students: ('홍길동', '박찬호', '이용규', '강호동', '박승철', '김지은')
students[2:4]: ('이용규', '강호동')
students[2:4]: ('홍길동', '박찬호', '이용규', '강호동')
students[2:4]: ('이용규', '강호동', '박승철', '김지은')
students[2:4]: ('이용규', '강호동')
students[2:4]: ('박찬호', '이용규', '강호동')

리스트와 튜플

리스트와 튜플 차이점

튜플은 리스트와 달리 아이템 추가, 변경, 삭제가 불가하다.
튜플은 선언 시 괄호 생략이 가능하다.

리스트와 튜플 변환

리스트와 튜플은 자료형 변환이 가능하다.

students = ['홍길동', '박찬호', '이용규', '강호동']
print('students: {}' .format(students))
print('students type: {}' .format(type(students)))

students = tuple(students)
print('students: {}' .format(students))
print('students type: {}' .format(type(students)))

students = list(students)
print('students: {}' .format(students))
print('students type: {}' .format(type(students)))

# 결괏값:
students: ['홍길동', '박찬호', '이용규', '강호동']
students type: <class 'list'>
students: ('홍길동', '박찬호', '이용규', '강호동')
students type: <class 'tuple'>
students: ['홍길동', '박찬호', '이용규', '강호동']
students type: <class 'list'>

실습

playerScore = (9.5, 8.9, 9.2, 9.8, 8.8, 9.0)
print('playerScore: {}' .format(playerScore))
print(type(playerScore))

playerScore = list(playerScore)
print(type(playerScore))

playerScore.sort()
print('playerScore: {}' .format(playerScore))
playerScore.pop()
playerScore.pop(len(playerScore) - 1)

playerScore = tuple(playerScore)
print('playerScore: {}' .format(playerScore))
print(type(playerScore))

sum = 0
avg = 0
for score in playerScore:
    sum += score

avg = sum / len(playerScore)

print('총점: %.2f' % sum)
print('평점: %.2f' % avg)

# 결괏값:
playerScore: (9.5, 8.9, 9.2, 9.8, 8.8, 9.0)
<class 'tuple'>
<class 'list'>
playerScore: [8.8, 8.9, 9.0, 9.2, 9.5, 9.8]
playerScore: (8.8, 8.9, 9.0, 9.2)
<class 'tuple'>
총점: 35.90
평점: 8.98