Lesson 03: 파이썬 자료형 심화개념

Author

최규빈

Published

January 30, 2023

ref

https://guebin.github.io/IP2022/2022/03/16/(3주차)-3월16일.html

https://guebin.github.io/IP2022/2022/03/16/(3주차)-3월16일.html#튜플고급

튜플고급

튜플을 왜 쓰지? (1)

그냥 리스트를 쓰면 되는거 아닌가 하는 생각이 듭니다. 그냥 튜플은 값이 바뀌지 않는 리스트 느낌. 이게 왜 쓸모있지?

  • 책의설명: 코딩을 하다보면 값을 바꾸지 말아야 할 것을 실수로 값을 바꾸는 경우가 있음. 이런 실수를 방지할 수 있다.
  • shallow copy/deep copy 에 대한 개념을 모르면 생기는 여러가지 side effect이 있음. 이러한 side effect을 막을 수 있는 무기임.

슬기로운 튜플 사용 (\(\star\star\star\star\star\))

상황1: 다중출력(?)

- 예제: 여러변수를 동시에 출력하고 싶을 경우 (다중출력?)

변수를 아래와 같이 선언하였다고 하자.

a=1
b=2
c=3

선언된 값을 확인하려면?

a
1
b
2
c
3

튜플을 이용하면?

a,b,c # 괄호하나 생략하는것이 이렇게 편하다..
(1, 2, 3)

상황2: 다중할당

- 예제: 다중할당1 (여러개의 변수를 동시에 선언하고 싶을 경우)

name, age, sex, height, weight = 'Tom', 20, 'M', 180, 70 
name, age, sex, height, weight
('Tom', 20, 'M', 180, 70)
height
180

- 예제: 다중할당2, 위도와 경도

coor = (37,127) # 서울 
coor
(37, 127)
lat, lon = coor
lat 
37
lon
127

- 잠깐만: 다중할당은 꼭 튜플에서만 가능한가?

그건 아니다…

[x,y,z] = [1,2,3] 
x,y,z # 다중출력 
(1, 2, 3)
[x,y] = 'hi'
x,y 
('h', 'i')

튜플과 같이 사용하면 가독성이 극대화 (그래서 다중할당은 거의 튜플과 세트로 사용함)

x,y,z = 1,2,3
x,y,z # 다중출력 
(1, 2, 3)
x,y = 'hi'
x,y 
('h', 'i')

상황3: 변수값을 교환

- 예제: 임시변수 사용없이 두 변수의 값을 교환

a=10
b=20
a,b = b,a 
a
20
b
10

상황4: for문과 함께

- 예제: for문과 튜플

lst = [['guebin', 202112345, 'M'],
       ['iu',202254321, 'F'],
       ['hodong', 202011223, 'M']]
lst
[['guebin', 202112345, 'M'],
 ['iu', 202254321, 'F'],
 ['hodong', 202011223, 'M']]
for i in lst: 
    print(i)
['guebin', 202112345, 'M']
['iu', 202254321, 'F']
['hodong', 202011223, 'M']
for name,studentid,sex in lst: 
    print(name)
guebin
iu
hodong
for name,studentid,sex in lst: 
    print(name,sex)
guebin M
iu F
hodong M

- 예제: for문과 튜플, dummy variable _

for name,studentid,sex in lst: 
    print(studentid)
202112345
202254321
202011223
for _,studentid,_ in lst: 
    print(studentid)
202112345
202254321
202011223
for _,_,sex in lst: 
    print(sex)
M
F
M
for name,_,sex in lst: 
    print(name,sex)
guebin M
iu F
hodong M

- 예제: for문과 튜플, * 연산자

(motive)

for name,_,_  in lst: 
    print(name)
guebin
iu
hodong
  • 귀찮냐..

(신기술)

for name,*args  in lst: 
    print(name)
guebin
iu
hodong

상황4: 언패킹연산자와 함께

- 예제: 튜플과 언패킹연산자 *

head, body, *tail = range(1,11) 
head, body, tail
(1, 2, [3, 4, 5, 6, 7, 8, 9, 10])
head1,head2, *body, tail1,tail2,tail3 = range(1,11) 
head1,head2, body, tail1,tail2,tail3 
(1, 2, [3, 4, 5, 6, 7], 8, 9, 10)
*head, body, tail = range(1,11) 
head, body, tail
([1, 2, 3, 4, 5, 6, 7, 8], 9, 10)

Appendix: 언패킹연산자

(관찰)

그러고 보니까..

head1,head2, body, tail1,tail2,tail3  = (1, 2, [3,4,5,6,7], 8, 9, 10)
head1,head2, *body, tail1,tail2,tail3   = (1, 2, 3,4,5,6,7, 8, 9, 10)

이렇다는 거잖아?

*를 붙이면 1차원 자료구조가 풀린다..?

*[1,2,3] # ?? 뭐하누?
SyntaxError: can't use starred expression here (<ipython-input-6-a543979d8d3c>, line 4)
print(*[1,2,3]) ## 이런 느낌!!
1 2 3
print([1,2,3]) # 비교
[1, 2, 3]

튜플을 왜 쓰지? (2)

- 책의 설명 (이 설명이 꼭 파이썬에 한정되는 것은 아님. 모든 언어에 존재하는 불변형 객체에 적용가능한 설명)

  • 실수방지
  • 빠르다, 다중작업에 유리하다, 여러사람과 작업하기에 유리하다, 깊은복사/얕은복사시 원하지않는 오류(side effect이라고 함)를 방지할 수 있다, 메모리관리에도 유리함…
  • 느낌: 불변형은 기능제한이 있는데 가볍고 빠른, 가변형은 기능은 풍부하지만 약간 느리고 무거운 느낌임 (불변형:라면사리, 가변형:라면)

- 제 생각

  • 튜플의 장점은 소괄호의 생략에 있음 (이것은 파이썬과 줄리아만 가능)
  • 이것이 언패킹구문과 결합하여 엄청난 가독성을 제공

(예시) 튜플의 막강함

def mycal(a,b):
    return a+b, a-b, a*b, a/b  #여러개의 값을 리턴하는듯 보임. -> 사실은 길이가 4인 튜플 1개를 리턴
mycal(2,3)
(5, -1, 6, 0.6666666666666666)
_, _, mulrslt, _ = mycal(2,3) # 병렬할당 
mulrslt
6

- 의문: 왜 튜플만 괄호를 생략할 수 있지?

- 내 망상

  • 튜플을 먼저 만들고, 괄호를 생략하는 문법을 추가한것은 아닐것임
  • 원래 괄호없이 컴마만 대충찍어서 선언가능한 아주 간단한 타입의 벡터형을 만들고 싶었을 것임.
  • 왜? 괄호없는 벡터를 만들고 + 언패킹을 사용하면 여러가지 구문들이 엄청나게 간단해짐.
  • 컴마컴마로 선언하는 벡터는 한 두번 쓰고 버리는 경우가 많으며 대부분 이름도 필요없음 \(\to\) 원소에 접근해서 sorting하여 순서를 바꾸고 싶다던가 원소를 추가할 이유가 없음 \(\to\) 비싼 가변형으로 만들 이유가 없다는 것..
  • 우리가 필요한 것: 데이터가 벡터의 형태로 모여있기만 하면 된다!

- 다른 사람들 의견 (컴공과 인터뷰)

  • 튜플 + 언패킹에 충격 \(\to\) 파이썬 편하더라..

인덱싱고급 (스트라이딩)

- 스트라이딩 [start:stop:step]

lst = list('abcdefgh')
lst
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
lst[0:8:2]
['a', 'c', 'e', 'g']

- 생략

lst[::2]
['a', 'c', 'e', 'g']
lst[0::2]
['a', 'c', 'e', 'g']
lst[:8:2]
['a', 'c', 'e', 'g']

- 예제: 짝수/홀수 원소 추출

lst
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
lst[::2] # 1,3,5,7, ... 
['a', 'c', 'e', 'g']
lst[1::2] # 2,4,6,8, ... 
['b', 'd', 'f', 'h']

- step = -1 이면?

lst
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
lst[::-1]
['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
  • reverse와 같은 기능

(reverse)와 비교

관찰1: reverse 메소드는 리스트 자체를 변화시킴

lst = list('abcdefgh')
lst
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
lst.reverse() #리버스는 
lst
['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

관찰2: [::-1]는 리스트는 변화시키지 않음

lst = list('abcdefgh')
lst
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
lst[::-1]
['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
lst
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

- 사실 -step은 쓰는 것이 조금 까다롭다.

(예제) 처음과 끝을 생략하지 않고 아래와 동일한 효과를 주는 코드를 만들어 보자.

lst = list('abcdefgh')
lst[::-1]
['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

(풀이)

결국 lst[?:?:-1]의 꼴에서 적당히 ?의 값을 채우면 된다.

lst[-1::-1] # 일단 첫 시작은 제일 마지막 원소 
['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
lst[-1:0:-1] # 앗 마지막 인덱스는 포함 안되는거였지? 
['h', 'g', 'f', 'e', 'd', 'c', 'b']
lst[-1:-1:-1] # 뭐 어쩌란거임 
[]

잠깐 인덱스를 생각해보자.

a b c d e f g h
0 1 2 3 4 5 6 7
-8 -7 -6 -5 -4 -3 -2 -1 
lst[-1:-9:-1] # 아..
['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

(예제)

lst[2::2]
['c', 'e', 'g']
lst[-2::-2]
['g', 'e', 'c', 'a']
lst[-2:2:2]
[]
lst[2:2:2]
[]
lst[2:2:-2]
[]

결론: -step을 자주 쓰진 말자?

컴프리헨션 고급 (if문이 포함된 컴프리헨션)

- 예제: 제곱수중에서 12로 나누어 떨어지는 수만 원소로 가지는 리스트를 만들고 싶다.

  • 제곱수: 1,4,9,16,25,36, …
  • 12로 나누어 떨어지는 수: 36, …

(예비학습)

12 % 4 # %는 나머지를 계산하는 연산자, 12를 4로 나누면 나머지가 0
0
12 % 5 # %는 나머지를 계산하는 연산자, 12를 5로 나누면 나머지가 2
2

(풀이1)

lst = [] 
for i in range(1,101): 
    if (i**2 % 12 == 0): 
        lst.append(i**2)
lst
[36,
 144,
 324,
 576,
 900,
 1296,
 1764,
 2304,
 2916,
 3600,
 4356,
 5184,
 6084,
 7056,
 8100,
 9216]

(풀이2)

[i**2 for i in range(1,101) if (i**2 % 12 == 0)]
[36,
 144,
 324,
 576,
 900,
 1296,
 1764,
 2304,
 2916,
 3600,
 4356,
 5184,
 6084,
 7056,
 8100,
 9216]

함수고급 (조건부리턴)

- 홀수/짝수를 판별하는 함수 만들기 1

def test(a):
    if a % 2 ==0: 
        return 'even'
    else:
        return 'odd'
test(1)
'odd'
test(2)
'even'
test(3)
'odd'
test(4)
'even'
[test(a) for a in range(1,11)]
['odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even']

- 홀수/짝수를 판별하는 함수 만들기 2

def test(a):
    return 'even' if a%2 ==0 else 'odd'
test(3)
'odd'
[test(a) for a in range(1,11)]
['odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even']

len함수

- 0차원 자료형은 len함수가 동작하지 않음

a=1 
len(a)
TypeError: object of type 'int' has no len()
a=True
len(a)
TypeError: object of type 'bool' has no len()
a=3.14
len(a)
TypeError: object of type 'float' has no len()

note: 이것이 어떠한 수학적인 의미를 가지거나 0차원의 본질적진리를 뜻하는 것은 아님. R에서는 1,3.14,TRUE의 길이가 1로 존재함.

- 1차원 자료형은 len함수가 동작

a='guebin'
len(a)
6
a=[1,2,3,4,5,6]
len(a)
6
a=1,2,3,4,5,6 
len(a)
6
a=range(10)
len(a)
10

- 길이가 1인 1차원 자료형과 0차원 자료형은 다른것임

a='g'
len(a)
1
a=[1] 
len(a)
1
a=(1,)
len(a)
1
a=range(1)
len(a)
1

- 길이가 0인 1차원 자료형도 존재함

a=''
len(a)
0
a=[]
len(a)
0
a=()
len(a)
0
a=range(0)
len(a)
0

str, list, tuple 비교

- str, list, tuple은 모두 시퀀스형이라는 공통점이 있다. \(\to\) 원소의 위치번호로 인덱싱이 가능

lst = [1,2,3,4]
lst[0] # 위치번호=0
1
lst[-1] # 위치번호=-1
4

- str, list, tuple은 차이점도 존재함. 잠깐 정리해보자.

시퀀스형의 카테고리

  • 컨테니어형: list, tuple
  • 균일형: str
  • 가변형: list
  • 불변형: tuple, str

표로 정리하면

컨테니어형 균일형
가변형 list .
불변형 tuple str

- 시퀀스형이 아닌 1차원 자료형도 있을까? (이원소의 위치번호로 인덱싱이 불가능한 자료형

- 왜 이런게 필요할까?

  • 벡터에서 원소를 뽑는것은 정보의 모임에서 정보를 검색하는 것과 같다.
  • 정보를 순서대로 나열한뒤에 그 순서를 이용하여 검색하는 방법은 유용하다.
  • 하지만 경우에 따라서는 키워드를 기억해서 그 키워드를 바탕으로 정보에 접근하는 방법이 유용할 수 있다.