Chapter 07. 데이터를 리스트와 튜플로 묶어보자

이번 시간의 목차

1. 리스트로 데이터를 묶어서 저장하자!

2. 리스트끼리 연산이 가능하다고?

3. 리스트에서 원하는 값만 잘라내고 싶으면? 슬라이싱!

4. 리스트를 좀 더 자세하게 다뤄 보자!

5. 리스트를 안전하게 복사해 보자!

6. 리스트를 간결하게 써 보자, 리스트 함축!

7. 한 번 정하면 바꿀 수 없는 튜플!

8. 클래스와 객체, 그리고 메소드

9. 마무리

 

 

 

자, 가자! 파이썬의 세계로!

---

 

리스트로 데이터를 묶어서 저장하자!

 

 우리는 앞에서 변수에 데이터를 저장한다고 배웠다. 지금까지는 주로 숫자와 문자열을 저장해봤는데, 이렇게 변수에 하나씩 저장하는 것 뿐만 아니라 여러 개의 데이터를 하나로 묶어 한꺼번에 저장하는 방법이 필요할 때도 있다. 

 

 이런 경우 파이썬에서는 리스트(List)와 딕셔너리(Dictionary)를 이용할 수 있다. 이번 장에서는 리스트에 대해 자세히 알아보자.

 

>>> height1 = 178  
>>> height2 = 173 
>>> height3 = 166
>>> height4 = 164
>>> height5 = 176
#위처럼 하나씩 다루려면 매우 번거롭다. 
 
>>> heights = [178, 173, 166, 164, 176]
>>> heights
[178, 173, 166, 164, 176]  #리스트에 저장하면 한 번에 다룰 수 있다!

 

 리스트를 만드는 방법은 간단하다. 대괄호 [ ] 속에 넣고 싶은 데이터를 넣으면 리스트가 만들어진다. 위의 예시 속 heights = [178, 173, 166, 164, 176] 은 5명의 키 정보를 담은 'heights'라는 리스트가 된다. 

 

 리스트에 저장되었다고 해서 무조건 이 정보를 통으로 다루게 되는 것은 아니다. 

리스트 속 각각의 데이터는 항목(Item) 또는 요소(Element)라고 한다. 이 항목들에 접근하려면 인덱스(Index)라는 정수를 이용해야 한다. 

 

 

 리스트에서 인덱스는 보통 가장 앞(왼쪽)에 놓인 것부터 차례대로 0, 1, 2… 로 가지게 된다. 쉽게 생각하자면 항목의 번호와 같은 것이다. 양의 정수가 아닌 음의 정수가 인덱스로 올 수도 있는데, 이때는 가장 뒤(오른쪽)에 놓인 것부터 차례대로 -1, -2, -3… 로 가지게 된다. 음수 인덱스는 리스트 속 데이터 개수가 너무 많아 끝이 몇 번째인지 알기 어려울 때 사용하면 좋다. 

 

>>> food = ['hamburger', 'pizza', 'pasta', 'steak', 'soup', 'noodle']
>>> food[0]    #food 리스트의 첫 번째 데이터에 접근
'hamburger'
>>> food[-2]   #food 리스트의 뒤에서 두 번째 데이터에 
'soup'

 

 각 항목을 불러올 때는 리스트이름[인덱스] 형식으로 입력하면 위처럼 해당 인덱스에 맞는 항목을 찾을 수 있다. 

 

 권장하지는 않지만, 꼭 한 리스트에 한 가지 자료형만 넣을 필요는 없다. 여러 가지 타입의 데이터를 섞어 저장할 수 있는 것이다. 

 

>>> student = ['Kim', 178, 'Park', 173, 'Lee', 176]
>>> student
['Kim', 178, 'Park', 173, 'Lee', 176]
>>> student[0], student[2], student[4]
('Kim', 'Park', 'Lee')

---

 

리스트끼리 연산이 가능하다고?

 

 파이썬에서는 리스트에 대해서도 다양한 연산이 가능하다. 

 

# 리스트에 + 연산자를 사용하면 리스트 속 항목을 합쳐준다.
>>> where1 = ['in', 'on', 'under']
>>> where2 = ['in front of', 'behind', 'next to', 'between']
>>> where = where1 + where2
>>> where
['in', 'on', 'under', 'in front of', 'behind', 'next to', 'between']
 
# - 연산자는 사용할 수 없다. 
>>> where - where2
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    where - where2
TypeError: unsupported operand type(s) for -: 'list' and 'list'
 
# * 연산자는 항목을 정수만큼 반복해서 저장해준다.
>>> where1 * 3
['in', 'on', 'under', 'in', 'on', 'under', 'in', 'on', 'under']
 
#리스트 속에 해당 값이 있는지를 보려면 in 과 not in 연산자를 사용한다. 
>>> 'in' in where1
True
>>> 'behind' in where1
False
>>> 'in' not in where1
False

 

 이때 명심해야 할 것이 하나 있다. + 연산자를 리스트끼리 적용한다고 해서 리스트 속 항목끼리 덧셈이 이뤄지는 것은 아니다. 리스트 속 항목끼리 덧셈을 시키려면 뒤에서 설명할 넘파이(Numpy)를 사용해야 한다. 

>>> num1 = [1, 2, 3, 4]
>>> num2 = [10, 11, 12, 13]
>>> num1 + num2
[1, 2, 3, 4, 10, 11, 12, 13]
#항목끼리 덧셈이 되지는 않는다.

 

---

 

리스트에서 원하는 값만 잘라내고 싶으면? 슬라이싱!

 

 리스트에서 여러 요소를 선택해서 새 리스트를 만들고 싶으면 슬라이싱(Slicing)이라는 기능을 사용하면 된다. 이 슬라이싱은 시퀀스형 자료형이면 어디에서든 쓸 수 있다. 인덱스 사이에 콜론을 넣어주면 슬라이싱이 된다. 

 

 

 슬라이싱을 할 때 heights[1:4]와 같이 적으면 1부터 시작해서 항목을 추출하다가 4번 인덱스에 도달하기 전에 추출을 멈춘다. 따라서 추출되는 항목의 인덱스는 1, 2, 3이 되며 4는 포함하지 않는다. 

 

 리스트를 슬라이싱하면 원래 리스트는 놔 두고 그 리스트의 값만 참조해서 새 리스트를 만들게 된다. 부분 복사본이라고 생각하면 편하다. 아래는 슬라이싱의 여러 표현법이다. 

 

>>> slist = list(range(0, 11))    #range(0, 11): 0부터 10까지의 수,
>>> slist                         # list() : 괄호 속 데이터를 리스트로 만든다.
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> slist[5:]        #5번 인덱스부터 끝까지 자른다.
[5, 6, 7, 8, 9, 10]
>>> slist[:3]        #처음부터 2번 인덱스까지 자른다.
[0, 1, 2]
>>> slist[:]         #처음부터 끝까지 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> slist[::2]       #처음부터 하나씩 건너뛰어 뽑아온다. 
[0, 2, 4, 6, 8, 10]  # 0 (1) 2 (3) 4 (5) 6 (7) 8 (9) 10
>>> slist[::-1]      #뒤에서부터 앞으로 읽어온다. 
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> slist[2 :: -1]   #2번 인덱스에서부터 앞으로 읽어온다.
[2, 1, 0]
>>> slist[2 : 9 : 2] #2번 인덱스에서 8번 인덱스까지 하나씩 건너뛰어 뽑는다.
[2, 4, 6, 8]

 

---

 

리스트를 좀 더 자세하게 다뤄 보자!

 

 리스트를 조금 더 자세하고 세밀하게 다루려면 어떻게 해야 할까? 우리는 단순하게 할당연산자 = 를 사용해서 값을 바꾸거나, 함수를 통해 원하는 값을 알아보고, 메소드를 통해 값을 새로 넣거나 삭제, 정렬할 수도 있다. 

 

 먼저 할당연산자를 통한 조작을 알아보자. 

예시를 들기 위해 위에서 만든 slist와 student 리스트를 가져와 봤다. 변수를 선언하듯이 바꾸고 싶은 항목을 = 의 왼쪽에, 어떻게 바꿀지를 오른쪽에 써주면 된다. 

 

>>> slist[1] = 1.5    #slist의 2번째 항목을 1.5로 수정한다.
>>> slist[2:4] = [2.5, 3.5] #slist의 3~4번째 항목을 2.5, 3.5로 수정한다.
>>> slist
[0, 1.5, 2, 3, 4, 5, 6, 7, 8, 9, 10]
------------------------------------
>>> student = [['Kim', 178], ['Park', 173], ['Lee', 176]]
>>> student[2][1] = 180  #student의 3번째 항목 중 2번째 항목을 180으로 수정한다.
>>> student
[['Kim', 178], ['Park', 173], ['Lee', 180]]

 

 

 다음으로는 함수를 이용한 탐색을 알아보자. 

함수 중에는 리스트 속 항목의 자료형에 따라 달라지는 기능이 있어 문자열로만 이루어진 리스트 wlist를 새로 만들었다. 

 

>>> slist  #숫자로만 이루어진 리스트
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> wlist = ['Apple', 'Banana', 'Chicken', 'Cinnamon', 'Grape'] #문자로 이루어진 리스트
>>> len(slist) #len()는 리스트의 길이, 즉 항목의 개수를 반환한다.
11
>>> max(slist) #max()를 숫자 리스트에 쓰면 항목의 최댓값을 반환한다.
10
>>> max(wlist) #max()를 문자열 리스트에 쓰면 알파벳 순서 가장 마지막을 반환한다.
'Grape'
>>> min(slist) #min()를 숫자 리스트에 쓰면 항목의 최솟값을 반환한다.
0
>>> min(wlist) #min()를 문자열 리스트에 쓰면 알파벳 순서 가장 빠른 항목을 반환한다.
'Apple'
>>> sum(slist) #sum()는 항목 전체의 합을 반환한다.
55
>>> sum(slist) / len(slist) #sum()과 len()으로 평균값을 구할 수도 있다.
5.0
>>> any(slist) #리스트 내에 0이나 공백이 아닌 원소가 하나라도 있는가?
True
>>> any(wlist)
True
 

 

 마지막으로 메소드를 이용한 조작을 알아보자. 

저번 시간에 배웠지만 메소드를 활용하려면 (리스트 이름).메소드() 형식을 사용한다. 간단한 예시로 원하는 위치에 항목을 추가하는 insert(index, item) 메소드를 살펴보자.

 

>>> alist = ['Apple', 2, 'Banana', 4, 'Grape', 1]  #과일과 개수를 나타내는 리스트
>>> alist.insert(2, 'Apricot')                     #2와 'Banana' 사이에 'Apricot' 추가
>>> alist.insert(3, 1)                             #'Apricot'과 'Banana' 사이에 1 
>>> alist
['Apple', 2, 'Apricot', 1, 'Banana', 4, 'Grape', 1]

 

 insert(index, item)에서 index부분에 원하는 자리(인덱스)를, item부분에 넣을 데이터를 입력해주면 위처럼 새 항목이 추가되는 것을 볼 수 있다. 자리가 상관 없다면 append()함수를 사용할 수도 있다. 

 

 아래는 리스트의 다양한 메소드와 그 결과를 정리한 것이다.

메소드	하는 일	alist = [1, 2, 3, 4, 5], x, x1, x2, index = 4
index(x)	원소 x를 이용하여 위치를 찾는다.	4
append(x)	원소 x를 리스트의 끝에 추가한다.	alist = [1, 2, 3, 4, 5, 5]
count(x)	리스트 내에서 x 원소의 개수를 반환한다.	1
extend([x1, x2])	[x1, x2] 리스트를 기존 리스트에 삽입한다.	alist = [1, 2, 3, 4, 5, 5, 5]
insert(index, x)	원하는 index 자리에 x를 추가한다.	alist = [1, 2, 3, 4, 5, 5]
remove(x)	x 원소를 리스트에서 삭제한다.	alist = [1, 2, 3, 4]
pop(index)	index 위치의 원소를 삭제 후 반환한다.  index를 생략할 경우 맨 마지막 원소가 반환된다.	5 alist = [1, 2, 3, 4]
sort()	리스트를 오름차순 정렬한다.  인자로 reverse = True를 주면 내림차순 정렬한다.	>>> nlist.sort(reverse = True) >>> nlist [5, 4, 3, 2, 1]
reverse()	리스트를 원래 원소의 역순으로 만든다.	alist = [5, 4, 3, 2, 1]

 

 이때 sort() 메소드는 원래 있던 리스트를 정렬하는 것이므로, 원래 있던 리스트와 정렬된 리스트를 따로 두고 싶다면 sorted() 함수를 사용하면 된다.

 

>>> numbers = [5, 6, 2, 3, 1]
>>> numbers_new = sorted(numbers)
 
>>> numbers_new
[1, 2, 3, 5, 6]
>>> numbers
[5, 6, 2, 3, 1]

 

 역순으로 정렬하고 싶으면 sorted(numbers, reverse = True)처럼 reverse = True를 붙여주면 된다.

 

 항목을 삭제하는 방법은 위의 메소드 remove(), pop() 두 가지 외에도 명령어를 통한 방법이 하나 더 있다. 

 

>>> alist = ['Apple', 2, 'Apricot', 1, 'Banana', 4, 'Grape', 1]
>>> del alist[0], alist[0]
>>> alist
['Apricot', 1, 'Banana', 4, 'Grape', 1]

 

 바로 명령어 del을 사용하는 방법이다. 말 그대로 delete, 삭제하는 명령어다. 이 명령어는 리스트의 메소드가 아니기 때문에 (리스트 이름).del( )로 사용하면 안 된다. 또 위처럼 여러 항목을 한 번에 삭제할 때에는 인덱스를 주의해서 써 줘야 한다. del alist[0], alist[0]을 수행하면 alist[0]을 먼저 삭제하고 [2, 'Apricot', 1, 'Banana', 4, 'Grape', 1]만 남은 리스트에서 다시 alist[0]를 삭제하게 된다. 헷갈려서 alist[0], alist[1]처럼 명령을 입력하는 일이 없도록 하자. 

 

---

 

리스트를 안전하게 복사해 보자!

 

 만약 하나의 리스트를 복사하고 싶을 땐 어떻게 해야 할까? 그냥 할당 연산자 =를 쓰면 되는 걸까?

그렇게 해도 상관은 없지만... 한 가지 문제가 생긴다. 

 

>>> alist
['Apple', 2, 'Apricot', 1, 'Banana', 4, 'Grape', 1]
>>> blist = alist
>>> blist
['Apple', 2, 'Apricot', 1, 'Banana', 4, 'Grape', 1]
---------------------------------------------------
#blist 속 사과의 개수를 5로 늘려봤다. 
>>> blist[1] = 5
>>> blist
['Apple', 5, 'Apricot', 1, 'Banana', 4, 'Grape', 1]
>>> alist
['Apple', 5, 'Apricot', 1, 'Banana', 4, 'Grape', 1] # ?? 

 

 분명 blist에의 2번째 항목을 5로 수정했는데 alist의 2번째 항목도 5로 바뀌어 있다. 

이는 alist가 원소를 갖고 있는 것이 아니라 리스트가 저장된 메모리의 주소만을 가지고 있기 때문이다. blist = alist라고 선언하면 리스트를 복사한 것이 아니라 리스트 속 데이터의 주소를 복사한 것이기 때문에 동일한 주소를 다루게 된다. 

 

 이렇게 변수의 이름이 실제 존재하는 메모리 속 객체를 가리키는 것을 참조(Reference)라고 한다. 파이썬에서 변수의 이름은 모두 객체에 대한 참조로 이루어진다. 이때문에 객체의 실제 메모리 위치를 알아야 할 때가 있는데, id()함수를 쓰면 객체에 대한 고유 식별번호를 알 수 있다. 위의 alist, blist의 아이디를 조회하면 동일한 결과가 나온다. 

 

>>> id(alist)
2855432946048
>>> id(blist)
2855432946048

 

 그렇다면 동일한 내용, 다른 주소를 갖는 리스트를 만들려면 어떻게 해야 할까? 

우리는 앞서 연속하는 정수를 리스트로 만들 때 list() 함수를 사용한 적이 있다. list() 함수는 괄호 속 데이터를 리스트로 새로 만들어주기 때문에 blist = list(alist)라는 선언을 해 주면 동일한 내용, 다른 id를 가진 두 리스트가 만들어진다. 

 

>>> alist
['Apple', 5, 'Apricot', 1, 'Banana', 4, 'Grape', 1]
>>> blist = list(alist)
>>> blist
['Apple', 5, 'Apricot', 1, 'Banana', 4, 'Grape', 1]
 
>>> blist[1] = 3   #blist 속 사과의 개수를 3으로 줄인다.
>>> alist
['Apple', 5, 'Apricot', 1, 'Banana', 4, 'Grape', 1] #alist는 바뀌지 않는다.
>>> blist
['Apple', 3, 'Apricot', 1, 'Banana', 4, 'Grape', 1]
 
>>> id(alist)  #두 리스트의 아이디가 다르다.
2855432946048
>>> id(blist)
2855464260608

 

 역시 blist 항목의 값을 바꿔도 alist는 바뀌지 않는 것을 볼 수 있다. 

 

---

 

리스트를 간결하게 써 보자, 리스트 함축!

 

 파이썬에서는 리스트 함축(List Comprehension)이라는 기능을 지원한다. 따로 용어를 붙이자니 조금 어려워 보이기도 하지만, 간단하게 말하자면 수학에서 집합의 한 표현법과 비슷한 것이다. 바로 간단한 예를 들어보자. 

 

#{x^2 | 1 <= x <= 10, x는 자연수}
>>> double = [ x ** 2 for x in range(1, 11) ] #x 제곱을 1부터 10까지 반복해서 리스트에 넣는다.
>>> double
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 

이렇게 리스트 함축 표현을 사용하면 입력 리스트의 각 항목을 하나하나 방문하며 지정된 연산을 하고, 연산의 결과로 생성된 항목값을 가지는 리스트를 생성할 수 있다. 꼭 숫자가 아니더라도, 이렇게 문자열에도 적용이 가능하다. 

 

>>> word = 'Hello World'
>>> [x.upper() for x in word] #word의 문자열 하나하나를 대문자로 만든다.
['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']
-----------------------------------------------------------------------
>>> words = ['hello', 'world', 'and', 'python']
>>> [x[0].upper() for x in words]  #words 속 단어의 첫 알파벳만 대문자로 만든다.
['H', 'W', 'A', 'P']

 

 이 함축 표현에는 조건을 붙일 수도 있다. 

앞에서 조건을 붙이려면 if문을 사용한다는 것을 배웠다. 리스트 함축 표현 중 연산 부분의 뒤로 조건을 붙여주면 조건에 따라 연산을 진행해준다. 

 

>>> [x for x in range(11) if x % 2 == 0] #x를 2로 나눴을 때 나머지가 2면 리스트에 넣는다.
[0, 2, 4, 6, 8, 10]
 
>>> s = ["Hello", "12345", 'World', "67890"] #문자와 숫자가 섞인 문자열 리스트
>>> p = [x for x in s if x.isdigit()] #isdigit() 함수는 문자열이 숫자로만 이루어졌는지를 확인한다.
>>> p
['12345', '67890']

 

 이런 기능을 잘 사용한다면 주어진 정보에서 필요없는 값을 제외한 리스트를 따로 만들어 데이터를 쉽게 다룰 수 있을 것이다. 

 

---

 

한 번 정하면 바꿀 수 없는 튜플!

 

 파이썬의 데이터형은 크게  불변속성(Immutable)형과 가변속성(Mutable)형의 두 가지로 나누어진다. 앞에서 배운 리스트는 얼마든지 조작이 가능했으므로 가변속성형이라 할 수 있다. 

 

 하지만 지금 다룰 튜플(Tuple)이라는 자료형은 불변속성형이다. 리스트와 아주 유사한 자료형이지만, 튜플의 내용은 한 번 정의되면 변경할 수 없다. 얼핏 보면 리스트가 더 편해 보이지만, 튜플도 나름의 장점이 있다. 변경이 불가능하기 때문에 구조가 단순하고, 리스트에 비해 접근 속도가 빠르다. 그러므로 필요한 때에 튜플과 리스트를 섞어 써야 한다. 

 

>>> num = (1, 2, 3)
>>> num
(1, 2, 3)
 
>>> num[0]
1
>>> num[0] = 10
Traceback (most recent call last):
  File "<pyshell#174>", line 1, in <module>
    num[0] = 10
TypeError: 'tuple' object does not support item assignment
 
>>> num1 = num + (1, 3)
>>> num1
(1, 2, 3, 1, 3)

 

 리스트가 대괄호 [ ]로 만들어진다면, 튜플은 소괄호 ( ) 로 만들 수 있다. 튜플 속에 들어가는 데이터는 리스트와 동일하다. 인덱스로 각각의 데이터에 접근할 수도 있다. 다만 인덱스와 등호를 사용해도 불변속성형이기 때문에 값을 바꿀 수는 없다. 

 

 튜플도 시퀀스 자료형이기 때문에 슬라이싱도 가능하고, 튜플간 + 연산자나 * 연산자를 사용할 수도 있다. 

 

---

 

클래스와 객체, 그리고 메소드

 

 프로그램 코드가 복잡해지면 관리하기 어려워지기 마련이고, 이를 해결하기 위해 만들어진 방법 중 하나가 객체지향 프로그래밍(Object-Oriented Programming)이다. 

 

 객체지향 프로그래밍은 다양한 객체를 클래스(Class)로 미리 정의해두고 이 객체들이 프로그램 상에서 상호작용하며 원하는 작업을 수행하는 문제해결 방식이다. 앞서 살펴봤던 리스트나 튜플 역시 클래스라고 할 수 있다. 이 객체들은 클래스의 틀을 지키면서 각자 서로 다른 값을 담고 있다. 이런 객체를 인스턴스(Instance) 객체라고 한다. 

 

 이때까지 살핀 자료형, 함수, 모듈도 모두 객체이다. 또, 앞서 살펴본 리스트의 기능 중 메소드(Method)라는 것도 있었다. 클래스에 속한 객체들이 사용할 수 있는 함수들을 메소드라고 부른다. 앞에서 몇 번이나 사용해 봤지만, 메소드를 사용할 때는 객체.메소드() 형태로 호출한다.

 

 파이썬도 '객체지향 프로그램이 언어'다. 객체지향 언어는 리스트와 같은 클래스를 정의할 수 있고, 해당 클래스의 인스턴스 객체를 생성할 수 있으며, 이 메소드를 이용하여 다양한 일을 할 수 있도록 지원하는 언어를 의미한다. 

 

 

 

 객체와 클래스에 대해서는 위를 보면 좀 더 이해하기 쉽다. 

 

---

 

마무리

 

 이번 시간에는 리스트와 튜플, 그리고 객체지향 프로그래밍에 대해 알아보았다. 

마지막으로 심화문제 7.2, 7.6, 7.7, 7.8, 7.9를 풀어보고 마치도록 하자. 접은글 속 해답코드는 참고만 하자. 

 

7.2: 다음과 같은 list1, list2가 있을 경우 이중 for 루프를 사용하여 list1과 list2의 각 원소를 곱한 후 원소의 곱셈을 아래와 같이 출력하시오. 

list1 = [3, 5, 7]
list2 = [2, 3, 4, 5, 6]
------------------------
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
5 * 2 = 10
...

list1 = [3, 5, 7]
list2 = [2, 3, 4, 5, 6]
for i in list1 :
    for t in list2 :
        print(i, '*', t, '=', i * t)

 

 

7.6: 사용자로부터 임의의 문자열을 입력으로 받은 후 이 문자열에 대하여 다음과 같은 피라미드 패턴을 만들어 출력하는 프로그램을 작성하여라. 이때 파이썬의 문자열 슬라이싱 기능을 사용하도록 하여라. 

p
py
pyt
pyth
pytho
python
pytho
pyth
pyt
py
p

word = input('문자열을 입력하세요: ')
 
for i in range(len(word)+1):   #첫 글자부터 하나씩 늘려 출력한다.
    print(word[:i])
 
for i in range(len(word)+1):   #전체 글자에서 뒤에서부터 하나씩 줄여 출력한다.
    print(word[:len(word)-i-1])

 

 

7.7: fruit_list = ['banana', 'orange', 'kiwi', 'apple', 'melon']의 리스트가 존재한다. 

 

1) 이 fruit_list에서 가장 길이가 긴 문자열을 찾아서 출력하고 이 리스트에서 삭제하라. 이때 동일한 길이의 문자열이 있을 경우 이들을 모두 삭제해라. 

가장 길이가 긴 문자열 : banana, orange
fruit_list = ['kiwi', 'apple', 'melon']

fruit_list = ['banana', 'orange', 'kiwi', 'apple', 'melon']
maximum = len(max(fruit_list)) #banana와 orange가 6으로 가장 길다.
 
print('가장 길이가 긴 문자열 : ', end = " ")
 
for i in ['banana', 'orange', 'kiwi', 'apple', 'melon'] :
    if len(i) == maximum :
        print(i, end = ' ')
        fruit_list.remove(i)  #최대 길이와 같은 길이면 삭제
 
print('') #줄바꿈 
print('fruit_list =', fruit_list) #삭제하고 남은 리스트 
 

 

2) 이 fruit_list와 for 제어문을 이용하여 다음과 같은 문장을 출력하여라. 

banana : 문자열의 길이 6
orange : 문자열의 길이 6
kiwi : 문자열의 길이 4
apple : 문자열의 길이 5
melon : 문자열의 길이 5

fruit_list = ['banana', 'orange', 'kiwi', 'apple', 'melon']
 
for i in range (0, len(fruit_list)) :
    print('{} : 문자열의 길이 {}'.format(fruit_list[i], len(fruit_list[i])))
 

 

 

7.8: 사용자로부터 숫자 1보다 크고 10보다 작은 값 n을 입력으로 받아서 다음과 같이 뱀의 몸통처럼 증가하는 이차원 배열을 출력하는 뱀행렬을 생성하여라. 이 행렬의 특징은 n이 5일 때 5 * 5 크기의 2차원 배열을 생성하는데, 이때 홀수 번째 행이 숫자가 증가하는 방향이 될 경우 짝수 번째 행은 숫자가 감소하는 형태를 가지는 특징이 있다. 이 문제를 반드시 for 반복문과 리스트 슬라이싱을 사용하여 풀어보아라. 

n을 입력하시오 : 5
 
  1  2  3  4  5
 10  9  8  7  6
 11 12 13 14 15
 20 19 18 17 16
 21 22 23 24 25

A = int(input("n을 입력하시오 : "))
D = [x for x in range(1, A * A + 1)] #입력받은 정수의 제곱만큼 수를 생성
S = ""
 
for i in range(0, A) : #행의 개수만큼 반
    print("")
 
    #짝수행(0부터)에서 순방향
    if i % 2 == 0 :
        
        S = D[ (i * A) : (i * A) + A ]
        for t in range (0, len(S)) :
            print('{0:3d}'.format(S[t]), end = "")
 
    #홀수행(1부터)에서 역방향
    else :
        
        S = D[ (i * A) + (A-1) : (i * A) - 1 : -1 ]
        for t in range (0, len(S)) :
            print('{0:3d}'.format(S[t]), end = "")
 
#i가 0일 경우: if문을 따름 > S = D[0:5] > 1 2 3 4 5
#i가 1일 경우: else문을 따름 > S = D[5 + 4 : 5 - 1 : -1] = D[9:4:-1] > 10 9 8 7 6

 

 

7.9: 사용자로부터 두 문자열 A, B를 입력으로 받도록 하자. 그리고 A의 뒷부분과 B의 앞부분을 가장 길게 일치시켜 둘을 겹치게 만든 새로운 문자열 C를 만드는 프로그램을 작성하시오. 만약 A의 뒷부분과 B의 앞부분이 다르면 B를 A의 바로 뒤에 붙여야 한다. 다음 예시를 참고하여라. 이를 위하여 C = overlap(A, B)와 같이 A, B를 인자로 받아 C를 반환하는 함수 overlap()을 구현하여라. 

문자열 A	문자열 B	출력될 문자열 C
commu	mummy	commummy
boxok	xbox	boxokxbox
deter	detery	detery
waycom	ycomget	waycomget
tttttt	tttttt	tttttt

A = str(input('A = '))
B = str(input('B = '))
 
def overlap(A, B) :
 
    for i in range(0, len(A)) : #A의 길이 동안 반복된다. 
        last = A[i : len(A)] #문자열 A의 전체에서 앞글자를 하나씩 자른다.
        first = B[: len(A) - i] #문자열 B의 전체에서 뒷글자를 하나씩 자른다.
 
            #A = 'commu', B= 'mummy'
            #print(last, first)
            #commu mummy
            #ommu mumm
            #mmu mum
            #mu mu
            #u m
 
        if last == first :   #A의 뒷부분과 B의 뒷부분이 같을 때
            C = A[0 : len(A)] + B[len(A) - i : len(B)] #둘을 이어서 반환
            return C
 
        elif i == len(A) - 1 : #끝까지 비교했을 때 같은 부분이 없으면
            C = A + B          #둘을 바로 이어서 반환 
            return C
        
print('C =', overlap(A, B))\