생능출판사 (가칭)"데이터과학 파이썬" 코드 7장

7.1 리스트는 무엇이고 왜 필요한가

In [1]:
height = 178.9    # float 타입의 데이터를 저장한다.
In [2]:
height1 = 178.9    # float 타입의 데이터를 저장한다.
height2 = 173.5    # float 타입의 데이터를 저장한다.
height3 = 166.1    # float 타입의 데이터를 저장한다.
height4 = 164.3    # float 타입의 데이터를 저장한다.
height5 = 176.4    # float 타입의 데이터를 저장한다.
In [3]:
heights = [178.9, 173.5, 166.1, 164.3, 176.4]
heights
Out[3]:
[178.9, 173.5, 166.1, 164.3, 176.4]

7.2 여러개의 항목이 들어가는 리스트를 만들자

In [4]:
bts = ['V', 'Jungkook', 'Jimin']
In [5]:
bts = []
In [6]:
bts = []
bts.append("V")
bts
Out[6]:
['V']
In [7]:
bts.append("Jin")
bts.append("Suga")
bts
Out[7]:
['V', 'Jin', 'Suga']
In [8]:
bts = ['V', 'Jin', 'Suga', 'Jungkook']
bts = bts + ['RM']   # 덧셈 연자자로 멤버 'RM'을 추가함
bts
Out[8]:
['V', 'Jin', 'Suga', 'Jungkook', 'RM']
In [9]:
list(range(5))       # 0에서 5사이의 정수열을 생성(5는 포함안됨)
Out[9]:
[0, 1, 2, 3, 4]
In [10]:
list(range(0, 5))    # list(range(5))와 동일한 결과 
Out[10]:
[0, 1, 2, 3, 4]
In [11]:
list(range(0, 5, 1)) # list(range(0, 5))와 동일한 결과
Out[11]:
[0, 1, 2, 3, 4]
In [12]:
list(range(0, 5, 2)) # 생성하는 값을 2씩 증가시킴 
Out[12]:
[0, 2, 4]
In [13]:
list(range(2, 5))    # 2에서 5-1까지의 연속된 수 2, 3, 4을 생성
Out[13]:
[2, 3, 4]

7.3 리스트 연산을 해보자

In [14]:
bts = ['V', 'J-Hope'] + ['RM', 'Jungkook', 'Jin']
bts
Out[14]:
['V', 'J-Hope', 'RM', 'Jungkook', 'Jin']
In [15]:
numbers = [10, 20, 30] + [40, 50, 60]
numbers
Out[15]:
[10, 20, 30, 40, 50, 60]
In [16]:
mystery = [0, 1, 2] * 3   # [0, 1, 2]가 3회 반복되어 저장됨
mystery
Out[16]:
[0, 1, 2, 0, 1, 2, 0, 1, 2]
In [17]:
bts = ['V', 'J-Hope', 'RM', 'Jungkook', 'Jin', 'Jimin', 'Suga']
'V' in bts
Out[17]:
True
In [18]:
'V' not in bts
Out[18]:
False

LAB7-1

입력을 받아 맛있는 과일의 리스트를 만들어 보자

In [19]:
fruits = []
 
name = input('좋아하는 과일의 이름을 입력하시오: ')
fruits.append(name)
name = input('좋아하는 과일의 이름을 입력하시오: ')
fruits.append(name)
name = input('좋아하는 과일의 이름을 입력하시오: ')
fruits.append(name)
 
name = input('과일의 이름을 입력하세요: ')
if name in fruits:
    print('이 과일은 당신이 좋아하는 과일입니다.')
else:
    print('이 과일은 당신이 좋아하는 과일이 아닙니다.')
좋아하는 과일의 이름을 입력하시오: 사과
좋아하는 과일의 이름을 입력하시오: 배
좋아하는 과일의 이름을 입력하시오: 귤
과일의 이름을 입력하세요: 사과
이 과일은 당신이 좋아하는 과일입니다.

7.4 내장함수를 이용해서 리스트를 알차게 이용하자

In [20]:
slist1 = ['Kim', 178.9, 'Park', 173.5, 'Lee', 176.1]
slist1
Out[20]:
['Kim', 178.9, 'Park', 173.5, 'Lee', 176.1]
In [21]:
slist1[0], slist1[2], slist1[4]
Out[21]:
('Kim', 'Park', 'Lee')
In [22]:
slist2 = [ ['Kim', 178.9], ['Park', 173.5], ['Lee', 176.1] ]
slist2
Out[22]:
[['Kim', 178.9], ['Park', 173.5], ['Lee', 176.1]]
In [23]:
type(slist1)
Out[23]:
list
In [24]:
type(slist2)
Out[24]:
list
In [25]:
n_list = [200, 700, 500, 300, 400]
len(n_list)
Out[25]:
5
In [26]:
max(n_list)
Out[26]:
700
In [27]:
min(n_list)
Out[27]:
200
In [28]:
sum(n_list)
Out[28]:
2100
In [29]:
sum(n_list) / len(n_list)  # 전체의 합을 원소의 개수로 나누면 평균값을 얻을 수 있다
Out[29]:
420.0
In [30]:
list(range(1,11))
Out[30]:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
In [31]:
a_list = [0, '']
In [32]:
any(n_list)
Out[32]:
True
In [33]:
any(a_list)
Out[33]:
False

LAB 7-2 : 리스트에 인구를 저장해보자

  • 세 도시에 대전(daejeon)을 추가해 보도록 하자. 대전의 인구는 1,531천명이라고 가정하자. 그리고 이 네 도시중에서 가장 인구가 많은 도시의 인구와 가장 인구가 적은 도시의 인구, 그리고 네 도시의 인구의 평균을 출력해 보도록 하자.
In [34]:
# 인구 통계(단위: 천명) 
Seoul = 9765 
Busan = 3441 
Incheon = 2954 
city_pop = [ Seoul, Busan, Incheon ] # 변수들로 리스트 생성
print(city_pop)                                           # 리스트 데이터를 출력 
[9765, 3441, 2954]
In [35]:
# <문제에서 제시된 코드를 여기에 삽입한다>
Daejeon = 1531
city_pop.append(Daejeon)

max_pop = 0
min_pop = 1000000
pop_sum = 0
n = 0

for pop in city_pop:    # 순환문을 돌면서 최댓값, 최솟값을 구한다
    if pop > max_pop :
        max_pop = pop
    if pop < min_pop :
        min_pop = pop
    pop_sum += pop
    n += 1

print('최대 인구:', max_pop)
print('최소 인구:', min_pop)
print('평균 인구:', pop_sum / n)
최대 인구: 9765
최소 인구: 1531
평균 인구: 4422.75

7.5 인덱스를 사용하여 리스트의 항목에 접근하기

In [36]:
 letters = ['A', 'B', 'C', 'D', 'E', 'F'] 
In [37]:
letters[0]  # 리스트의 첫 항목에 접근
Out[37]:
'A'
In [38]:
letters[1] 
Out[38]:
'B'
In [39]:
letters[2] 
Out[39]:
'C'
In [40]:
letters[-1]
Out[40]:
'F'
In [41]:
bts = ['V', 'RM', 'Jungkook', 'J-Hop', 'Suga', 'Jin', 'Jimin']
len(bts)          # 리스트의 원소 개수를 얻는다
Out[41]:
7
In [42]:
bts[len(bts)-1]  # 마지막 원소
Out[42]:
'Jimin'
In [43]:
bts[-1]           # 음수 인덱스로 마지막 원소를 쉽게 접근할 수 있다
Out[43]:
'Jimin'
In [44]:
min(bts)        # 리스트 원소 중 가장 작은 값을 찾는다. (문자열은 사전식 순서)
Out[44]:
'J-Hop'
In [45]:
max(bts)        # 리스트 원소 중 가장 큰 값을 찾는다. (문자열은 사전식 순서)
Out[45]:
'V'
In [46]:
letters = ['A', 'B', 'C', 'D', 'E', 'F']
In [47]:
letters[0]
Out[47]:
'A'
In [48]:
letters[1]
Out[48]:
'B'
In [49]:
letters[2]
Out[49]:
'C'
In [50]:
letters[-1]
Out[50]:
'F'
In [51]:
alist = ['a', 'aa', 'ff', 'f', 'b', 'c']
len(alist)          # 리스트의 원소 개수를 얻는다
Out[51]:
6
In [52]:
alist[len(alist)-1] # 마지막 원소
Out[52]:
'c'
In [53]:
alist[len(alist)-1] # 마지막 원소
Out[53]:
'c'
In [54]:
min(alist)        # 리스트 원소 중 가장 작은 값을 찾는다. (문자열은 사전식 순서)
Out[54]:
'a'
In [55]:
max(alist)        # 리스트 원소 중 가장 큰 값을 찾는다. (문자열은 사전식 순서)
Out[55]:
'ff'

7.6 리스트를 원하는 모양으로 자르는 슬라이싱

In [56]:
letters = ['A', 'B', 'C', 'D', 'E', 'F'] 
letters[2:5]
Out[56]:
['C', 'D', 'E']
In [57]:
letters[:3]
Out[57]:
['A', 'B', 'C']
In [58]:
letters[3:] 
Out[58]:
['D', 'E', 'F']
In [59]:
letters[:] 
Out[59]:
['A', 'B', 'C', 'D', 'E', 'F']
In [60]:
letters[::2] 
Out[60]:
['A', 'C', 'E']
In [61]:
letters[::-1]       # 뒤에서부터 앞으로 읽어오며 원소를 생성한다 
Out[61]:
['F', 'E', 'D', 'C', 'B', 'A']

LAB7-3

도시의 인구 자료에 대한 슬라이싱을 해보자

In [62]:
# 다음과 같은 리스트가 생성되어 있다. 
population = ["Seoul", 9765, "Busan", 3441, "Incheon", 2954]

print('서울 인구:', population[1])     # 문제 1)
print('인천 인구:', population[-1])    # 문제 2)

cities = population[0::2]             # 문제 3)
print('도시 리스트:', cities)
pops = population[1::2]               # 문제 4)
print('인구의 합:', sum(pops))
서울 인구: 9765
인천 인구: 2954
도시 리스트: ['Seoul', 'Busan', 'Incheon']
인구의 합: 16160

7.7 리스트의 원소 값을 조작해 보자

In [63]:
slist = ['Kim', 178.9, 'Park', 173.5, 'Lee', 176.1] 
In [64]:
slist[3] = 175.0
In [65]:
slist
Out[65]:
['Kim', 178.9, 'Park', 175.0, 'Lee', 176.1]
In [66]:
slist[2:4] = ['Paik', 180.0]
slist
Out[66]:
['Kim', 178.9, 'Paik', 180.0, 'Lee', 176.1]
In [67]:
slist.insert(4, "Hong") 
slist.insert(5, 168.1) 
slist
Out[67]:
['Kim', 178.9, 'Paik', 180.0, 'Hong', 168.1, 'Lee', 176.1]

LAB7-3 : 슬라이싱 실

7.8 항목을 삭제하는 방법은 여러가지가 있다

In [68]:
bts = [ "V", "J-Hope", "Suga", "Jungkook" ] 
bts.remove("Jungkook") 
bts 
Out[68]:
['V', 'J-Hope', 'Suga']
In [69]:
bts = ["V", "J-Hope", "Suga", "Jungkook"] 
last_member = bts.pop()   # 마지막 항목 'Jungkook'을 삭제하고 반환한다
last_member
Out[69]:
'Jungkook'
In [70]:
bts
Out[70]:
['V', 'J-Hope', 'Suga']
In [71]:
bts = [ "V", "J-Hope", "Suga", "Jungkook"] 
del bts[0]     # 리스트의 첫 항목을 삭제하는 명령어
bts
Out[71]:
['J-Hope', 'Suga', 'Jungkook']

7.9 리스트의 객체의 생성과 참조라는 깊이있는 개념

In [72]:
alist = ['Kim', 'Park', 'Lee', 'Hong'] 
In [73]:
blist = alist 
blist[1] = 'Choi'  # blist의 두번째 항목값을 변경함
alist 
Out[73]:
['Kim', 'Choi', 'Lee', 'Hong']
In [74]:
id(alist)
Out[74]:
2222263129864
In [75]:
id(blist) # 위의 값과 동일함
Out[75]:
2222263129864

7.10 리스트를 복제한 새로운 리스트 만들기

In [76]:
alist = ['Kim', 'Park', 'Lee', 'Hong'] 
blist = list(alist) 
id(alist)
Out[76]:
2222262994568
In [77]:
id(blist)     # blist의 아이디는 alist의 아이디와 다를 것이다.
Out[77]:
2222263358664
In [78]:
blist = alist[:]      # 이렇게 하여도 된다. 
id(alist)
Out[78]:
2222262994568
In [79]:
id(blist)     # blist의 아이디는 alist의 아이디와 다를 것이다.
Out[79]:
2222262994824
In [80]:
blist[0] = 'Song'
alist         # alist의 복사본 blist를 고쳤으므로 아무런 변화가 없다
Out[80]:
['Kim', 'Park', 'Lee', 'Hong']
In [81]:
blist         # alist의 복사본의 첫 번째 항목이 변경됨
Out[81]:
['Song', 'Park', 'Lee', 'Hong']

7.11 리스트 탐색해보자

In [82]:
bts = [ "V", "J-Hope", "Suga", "Jungkook" ] 
bts.index("Suga") 
Out[82]:
2
In [83]:
if "Suga" in bts: 
    print(bts.index("Suga")) 
2
In [84]:
bts = ["V", "J-Hope", "Suga", "Jungkook" ] 
for member in bts: 
    print(member)
V
J-Hope
Suga
Jungkook

7.12 리스트를 크기에 따라 정렬해보자

In [85]:
numbers = [ 9, 6, 7, 1, 8, 4, 5, 3, 2 ]
numbers.sort()
print(numbers)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
In [86]:
numbers.sort(reverse=True) 
print(numbers) 
[9, 8, 7, 6, 5, 4, 3, 2, 1]
In [87]:
bts = [ "V", "J-Hope", "Suga", "Jungkook" ] 
bts.sort() 
print(bts)
['J-Hope', 'Jungkook', 'Suga', 'V']
In [88]:
numbers = [ 9, 6, 7, 1, 8, 4, 5, 3, 2 ]
new_list = sorted(numbers)
print(new_list)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
In [89]:
print(numbers)
[9, 6, 7, 1, 8, 4, 5, 3, 2]
In [90]:
numbers = [ 9, 6, 7, 1, 8, 4, 5, 3, 2 ]
new_list = sorted(numbers, reverse=True)
print(new_list)
[9, 8, 7, 6, 5, 4, 3, 2, 1]

도전문제

  • 다음 코드의 실행결과를 예상해 보고 직접 실행시켜보자.
In [91]:
sorted("FADEAWAY")
Out[91]:
['A', 'A', 'A', 'D', 'E', 'F', 'W', 'Y']

LAB7-4 : 오늘의 명언을 골라주는 기능을 만들자

In [92]:
import random 
 
quotes = [] 
quotes.append("꿈을 지녀라. 그러면 어려운 현실을 이길 수 있다.") 
quotes.append("분노는 바보들의 가슴속에서만 살아간다..") 
quotes.append("고생 없이 얻을 수 있는 진실로 귀중한 것은 하나도 없다.") 
quotes.append("사람은 사랑할 때 누구나 시인이 된다.") 
quotes.append("시작이 반이다.") 
 
print("############################") 
print("# 오늘의 명언 #") 
print("############################") 
print("") 
dailyQuote = random.choice(quotes) 
print(dailyQuote)
############################
# 오늘의 명언 #
############################

분노는 바보들의 가슴속에서만 살아간다..

도전문제

  • "100 + 200"과 같은 산수 문제를 10개 저장하고 있는 리스트를 작성하고 여기에서 랜덤하게 하나를 골라서 사용자에게 제공하는 프로그램을 작성하라. 다음과 같이 eval() 함수를 사용하면 문자열로 이루어진 이 문장을 파이썬 수식으로 평가하여 연산을 수행하는 것이 가능하다.
In [93]:
eval("100 + 200")  # 문자열을 파이썬 문장으로 해석하여 100 + 200을 수행함
Out[93]:
300

7.13 리스트 함축은 코드를 짧고 간결하게 만드는데 사용된다

In [94]:
[ x**2 for x in [1, 2, 3, 4, 5] ] 
Out[94]:
[1, 4, 9, 16, 25]
In [95]:
s = [] 
for x in [1, 2, 3, 4, 5]: 
    s.append(x**2)
In [96]:
[x for x in range(10)]# 0에서 9까지 숫자를 포함하는 리스트
Out[96]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [97]:
[x * x for x in range(10)] # 0에서 9까지 숫자의 제곱 값
Out[97]:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
In [98]:
st = 'Hello World'
[x.upper() for x in st]    # 문자열 각각에 대해 upper() 메소드 적용
Out[98]:
['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']
In [99]:
a = ['welcome', 'to', 'the', 'python', 'world']
first_a = [ s[0].upper() for s in a]  # 첫 알파벳에 대한 대문자 변환
print(first_a)
['W', 'T', 'T', 'P', 'W']

7.14 조건이 붙는 리스트 함축표현도 가능하다

In [100]:
[x for x in range(10) if x % 2 == 0]
Out[100]:
[0, 2, 4, 6, 8]
In [101]:
[x**2 for x in range(10) if x % 2 == 0]  # 출력식에 제곱을 할 수 있다
Out[101]:
[0, 4, 16, 36, 64]
In [102]:
s = ["Hello", "12345", "World", "67890"] 
numbers = [x for x in s if x.isdigit()] 
print(numbers)
['12345', '67890']
In [103]:
[int(x) for x in input('정수를 여러개 입력하세요 : ').split()]
정수를 여러개 입력하세요 : 10 20 30
Out[103]:
[10, 20, 30]
In [104]:
[int(x) for x in input('정수를 여러개 입력하세요 : ').split() if x.isdigit()]
정수를 여러개 입력하세요 : 20 30 40
Out[104]:
[20, 30, 40]
In [105]:
[(x, y) for x in [1, 2, 3] for y in [3, 1, 4]] 
Out[105]:
[(1, 3), (1, 1), (1, 4), (2, 3), (2, 1), (2, 4), (3, 3), (3, 1), (3, 4)]
In [106]:
[(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
Out[106]:
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

7.15 한번 생성하면 그 값을 고칠 수 없는 자료형 : 튜플

In [107]:
colors = ("red", "green", "blue") 
colors 
Out[107]:
('red', 'green', 'blue')
In [108]:
numbers = (1, 2, 3, 4, 5 ) 
numbers 
Out[108]:
(1, 2, 3, 4, 5)
In [109]:
t1 = (1, 2, 3, 4, 5)
t1[0] = 100
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-109-614bcaadef71> in <module>
      1 t1 = (1, 2, 3, 4, 5)
----> 2 t1[0] = 100

TypeError: 'tuple' object does not support item assignment
In [110]:
t1 = (1, 2, 3, 4, 5)
t1[0]          # 튜플의 인덱싱-리스트 인덱싱과 동일한 방식
Out[110]:
1
In [111]:
t1[1:4]        # 튜플의 슬라이싱 결과로 튜플을 반환함
Out[111]:
(2, 3, 4)
In [112]:
t2 = t1 + t1   # 튜플의 결합 연산
t2
Out[112]:
(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

LAB7-5 함수는 튜플을 돌려줄 수 있다

In [113]:
import math 
 
def calCircle(r): 
    # 반지름이 r인 원의 넓이와 둘레를 동시에 반환하는 함수 (area, circum) 
    area = math.pi * r * r 
    circum = 2 * math.pi * r 
    return area, circum    # 튜플을 반환함
 
radius = float(input("원의 반지름을 입력하시오: ")) 
(a, c) = calCircle(radius) 
print("원의 넓이는 "+str(a)+"이고 원의 둘레는"+str(c)+"이다.")
원의 반지름을 입력하시오: 10
원의 넓이는 314.1592653589793이고 원의 둘레는62.83185307179586이다.

LAB 7-6 : 도시의 이름과 인구를 튜플로 묶어보자

In [114]:
city_info = [('서울', 9765), ('부산', 3441), ('인천', 2954), 
             ('광주', 1501), ('대전', 1531)]
In [115]:
max_pop = 0
min_pop = 999999999999999999
total_pop = 0

max_city = None
min_city = None

for city in city_info:
   total_pop += city[1]
   if city[1] > max_pop :
       max_pop = city[1]
       max_city = city
   if city[1] < min_pop :
       min_pop = city[1]
       min_city = city

print('최대인구: {0}, 인구: {1} 천명'.format(max_city[0], max_city[1]))
print('최소인구: {0}, 인구: {1} 천명'.format(min_city[0], min_city[1]))
print('리스트 도시 평균 인구: {0} 천명'.format(total_pop / len(city_info)) )
최대인구: 서울, 인구: 9765 천명
최소인구: 광주, 인구: 1501 천명
리스트 도시 평균 인구: 3838.4 천명

7.16 클래스와 객체가 무엇인가?

In [116]:
animals = ['lion', 'tiger', 'cat', 'dog']
animals.sort()     # animals 리스트의 내부 문자열을 알파벳 순으로 정렬한다
animals
Out[116]:
['cat', 'dog', 'lion', 'tiger']
In [117]:
animals.append('rabbit')  # animals 리스트에 새 원소를 추가한다
animals
Out[117]:
['cat', 'dog', 'lion', 'tiger', 'rabbit']
In [118]:
animals.reverse()         # animals 리스트를 원래 원소의 역순으로 재배열한다
animals
Out[118]:
['rabbit', 'tiger', 'lion', 'dog', 'cat']