함수(function)란 실행문들을 묶어서 하나의 블럭으로 만든 후 이름을 붙인 것을 말한다. 이렇게 수행문들의 집합을 함수로 정의하면 그 수행문들을 동작시킬 때 함수 이름을 이용한 간단한 호출(call)로 반복해서 실행시킬 수 있다.


 파이썬 함수는 다음과 같이 정의된다.


def 함수명(인자1, 인자2, …):
함수 본체


함수의 정의는 항상 def로 시작한다. 함수명은 일반적인 식별자를 사용하며 관례적으로 (변수명과 마찬가지로) 소문자로 시작한다. 그다음에 호출하는 쪽에서 넘겨 받을 인자들의 리스트를 괄호(...)안에 콤마로 구별하여 지정해 주고 콜론(:) 뒤에 함수의 본체를 작성해 주면 된다. 함수의 본체는 반드시 def 의 첫 글자 시작 위치보다 들여 써야 한다.


 간단한 예를 들어보자


>>> def sayHi():
print(‘hi’)


이 함수는 ‘hi’라는 문자열을 출력하는 함수이며 함수의 이름은 sayHi()이다. 입력 인자는 없으며 반환값도 없다. 이 함수를 호출하려면 다음과 같이 하면 된다.


>>> sayHi()
Hi


구구단을 출력하는 함수를 예로 들어보자.


>>> def gugu(n):
...     for x in range(2,10):
...         print('%d x %d = %d'%(n,x,n*x))


이 함수는 하나의 입력 인자를 받도록 되어 있다. 다음과 같이 호출한다.


>>> gugu(4)
4 x 2 = 8
4 x 3 = 12
4 x 4 = 16
4 x 5 = 20
4 x 6 = 24
4 x 7 = 28
4 x 8 = 32
4 x 9 = 36

>>> gugu(8)
8 x 2 = 16
8 x 3 = 24
8 x 4 = 32
8 x 5 = 40
8 x 6 = 48
8 x 7 = 56
8 x 8 = 64
8 x 9 = 72


함수명은 함수객체이며 다른 객체와 유사하게 대입이 가능하다. 예를 들어 앞에서 정의한 함수 sayHi()와 gugu()를 하나의 리스트로 묶을 수 있다.


>>> fl = [sayHi, gugu]


여기서 fl 리스트의 첫 번째 요소는 함수 sayHi 이고 두 번째 요소는 gugu 이다. 따라서 다음과 같은 함수 호출이 가능하다.


>>> fl[0]()
Hi.
>>> fl[1](9)
9 x 2 = 18
9 x 3 = 27
9 x 4 = 36
9 x 5 = 45
9 x 6 = 54
9 x 7 = 63
9 x 8 = 72
9 x 9 = 81



또는 함수를 다른 변수에 대입할 수도 있다.


>>> kuku = gugu


이제 kuku 는 함수이며 gugu()함수와 같은 함수이다. 따라서 다음과 같이 동일하게 호출할 수도 있다.


>>> kuku(7)
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63


 가끔 함수의 본체를 구현하지 않고 껍데기만 작성해야 될 경우도 있다. 이럴 경우 다음과 같이 하면 된다.


>>> def nop(): pass


이 함수는 호출은 할 수 있으나 아무런 일도 수행하지 않는다.



Posted by 살레시오

댓글을 달아 주세요

 반복문 안에서 continue 명령은 그 이후의 반복문은 수행하지 않고 즉시로 다음 반복 실행으로 넘어가는 동작을 수행한다.


for n in lst:
   if n==0:
       continue
   print(n)


이 예제에서 lst의 요소가 만약 0 이라면 continue 명령을 만나게 되고 그 이후의 print(n)은 수행되지 않고 다음으로 바로 넘어가게 된다.


 이 예를 while 문으로 작성하면 다음과 같다.


k = 0
while k<len(lst) :
   if lst[k]==0:
       k +=1
       continue
   print(lst[k])
   k +=1


이와 같이 continue 명령은 반복문 안에서 사용되며 그것을 둘러싼 가장 안쪽의 반복문의 다음 단계로 즉시 넘어가는 동작을 수행한다.



Posted by 살레시오

댓글을 달아 주세요

 파이썬의 while 명령은 단순 반복을 수행한다.


while 조건식:
실행문
....


여기서 조건식이 참이면 실행문을 수행하고 다시 조건을 검사한다. 즉, 조건문이 거짓이 될 때까지 실행문을 반복 수행하는 것이다.


>>> m,p = 1,1
>>> while m<=10:
...     p *= m
...     m += 1
>>> p
3628800


이  예는 10! 을 구하는 프로그램이다. 10!=3628800 이라는 것을 알 수 있다.


 for문과 마찬가지로 while 문도 else 절이 붙을 수 있다.


while 조건식:
실행문들1
else:
실행문들2


조건식이 거짓으로 판정되어서 ‘실행문들1’이 수행되지 않을 때 else 절의 ‘실행문들2’가 수행된다. 만약 break 문에 의해서 반복이 끝난다면 (for반복문과 마찬가지로) else절은 수행되지 않고 그 바깥으로 빠져 나가게 된다.


n=3
while n>=0:
   m = input("Enter a interger :")
   if int(m)==0: break
   n -= 1
else:
   print('4 inputs.')


이 예제는 4개의 0이 아닌 정수를 입력 받으면 else 절이 수행된다.


.#실행 결과 1
Enter a interger :1
Enter a interger :2
Enter a interger :3
Enter a interger :4
4 inputs.


만약 그 전에 0이 입력된다면 else 절이 수행되지 않고 while 반복문을 완전히 종료하게 된다.


# 실행 결과 2
Enter a interger :0


for 반복문과 마찬가지로 break 문에 의한 반복 종료인지 아니면 조건문이 False 가 되어서 반복문을 종료하는 지를 구별하여 다른 실행문을 수행할 경우에 while ~ else 절을 사용하면 된다.


m=997
n=2
while n<m//2:
if m%n==0: break
n += 1
else:
print(m,'is a prime number!')


이 예는 997이 소수(prime number)인지 아닌지 판별하는 함수이다. 2부터 498까지 차례로 나누어서 나머지가 한번이라도 0이 된다면 break 문에 걸리게 된다. 만약 한 번도 0이 아니라서 반복문이 끝까지 돌았다면 else 절이 수행되어 소수임을 표시한다.(음영진 부분은 seq 형이다.)



Posted by 살레시오

댓글을 달아 주세요

 파이썬의 for 반복문 안에서 break 명령을 사용할 수 있는데 이 명령은 즉시 그것이 포함된 가장 안 쪽의 반복문을 빠져 나온다. 다음 반복문을 보자.


for n in lst:
   if n==0:
       break
   print(n)


이것은 lst 안의 요소들을 차례대로 프린트하다가 0이 발견되면 바로 반복을 멈추는 프로그램이다. 만약 lst=[1,2,3,0,4,5] 라면 1,2,3만 출력되고 반복문은 종료될 것이다. 만약 반복문의 중첩되어 있다면 가장 안쪽의 반복문만 빠져 나온다는 점에 유의해야 한다.


파이썬의 for 반복문은 else 명령과 짝을 이룰 수도 있다.


for 변수 in 반복가능자:
   수행문들1
else:
   수행문들2


else 블럭에 포함된 ‘수행문들2’는 for 반복문이 반복형의 마지막 요소까지 모두 반복했을 경우 그 다음에 수행된다. 즉, 모든 반복이 성공적으로 수행된 경우에 한 번 수행된다. 하지만 break문을 만나면 else 구문은 수행되지 않고 for 블럭을 완전히 빠져나간다.


for n in lst:
   if n==0: break
   print(n)
else:
   print(‘There is no 0.’) # break문을 만나지 않았다면 수행된다.


이 예제의 경우 lst 안에 0이 있다면 break를 만나게 되고 따라서  else 블럭은 수행되지 않고 for 반목문을 빠져 나오게 된다.


따라서 for 반복문이 종료된 시점에서 이 종료가 모든 반복을 다 수행한 후의 정상적인 종료인지, 아니면 break 명령에 의한 강제 종료인지에 따라서 수행해야 될 일을 구분할 필요가 있는 경우에 for~else 구문을 사용하면 된다.



Posted by 살레시오

댓글을 달아 주세요

 파이썬의 for 반복문은 C/C++의 그것과는 약간 다르다. (JAVA나 C#의 foreach 명령과 유사한 점이 많다.) 기본 적인 문법은 다음과 같다.


for 변수 in 반복형:
수행문


여기서 반복형은  열거형(sequence,  range형, 문자열, 리스트, 튜플 등), 딕셔너리 등이 있다.


 예로 기존의 리스트를 이용하여 리스트 요소들 중 짝수의 개수를 세는 프로그램을 작성해 보자.


>>> lst = [11, 44, 21, 55, 101]
>>> cnt = 0
>>> for n in lst :
if n%2==0:
cnt += 1
>>> cnt
1


이 예제는 리스트 lst 의 각 요소가 순서대로 n 변수에 대입되고 반복문이 수행된다.


range()함수와 range 형

 for 구문과 자주 같이 사용되는 파이썬 내장 함수 중에서 range() 함수가 있는데 이 함수는 range 형을 만들어 준다. (range 형은 시퀀스 형에 속한다.) for 반복문과 조합되어서 자주 사용되므로 여기에서 자세히 설명하도록 하겠다. range() 함수는 세 가지 용법이 있다. 다음에서 m, n, s는 정수이다.


range(n)  # 0 부터 n-1 까지의 요소를 가지는 range 형 반환
range(m,n)  # m 부터 n-1 까지의 요소를 가지는 range 형 반환
range(m,n,s)  # m 부터 n-1 까지의 요소(s는 step)를 가지는 range 형 반환


한 가지 주의할 점은 파이썬 3.x에서는 range()함수는 range 형을 반환한다. (반면 파이썬 2.x 에서는 리스트를 반환한다.) 따라서 파이썬 3.x에서는 이 rangeg형을 리스트로 만들기 위해서는 list()함수를 반드시 명시적으로 사용해야 한다.


>>> range(5)
range(0,5)
>>> list(range(5))
[0,1,2,3,4]
>>> list(range(1,11))
[1,2,3,4,5,6,7,8,9,10]
>>> list(range(0,30,5)) # 5가 증분
[0,5,10,15,20,25]
>>> list(range(0,-5,-1)) # -1이 증분
[0,-1,-2,-3,-4]
>>> list(range(0))
[]
>>> list(range(1,0))
[]


하지만 for문 안에서 range 함수를 사용할 경우 궂이 리스트로 바꿀 필요는 없다. 왜냐면 for 문에는 반복형(iterable)이 사용되며 range 객체는 열거형(sequence)이므로 반복형이기 때문이다.

예를 들어서 ‘hi.’라는 문자열을 다섯 번 출력하는 프로그램을 작성해 보자.


for _ in range(5):
print(‘hi.’)


이 반복문은 변수 _ 가 0,1,2,3,4 값을 가지고 각각 반복을 수행하게 된다. 실제 이 변수가 사용되지는 않으므로 그냥 _ 로 지정하였다. (파이썬에서 dummy variable 의 이름은 보통 _ 로 지정한다.)


구구단의 2단을 출력하는 프로그램을 작성해 보자.


>>> for n in range(2,10):
...     print('2 x %d = %d'%(n, 2*n))

2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18


여기서 변수 n은 2부터 9까지의 값을 가지고 반복문이 수행된다. range(2,10)은 2부터 9까지의 숫자를 차례로 생성한다.


for 반복문은 중첩해서도 얼마든지 사용할 수 있다. 구구단의 2단부터 9단까지 한꺼번에 출력하려면 다음과 같이 작성하면 될 것이다.


>>> for m in range(2,10):
...     for n in range(2,10):
...             print('%d x %d = %d'%(m,n,m*n))
...     print('-'*10)


여기에서 print(‘-’*10)은 ‘----------’ 을 출력한다.




Posted by 살레시오

댓글을 달아 주세요

  1. 잡다백수 2016.12.29 22:48  댓글주소  수정/삭제  댓글쓰기

    잘 보고 갑니다.

 if 명령은 그 뒤에 오는 조건식의 참/거짓 여부에 따라 속한 블럭을 수행할지 말지를 결정하는 명령이다. 가장 기본 문법은 다음과 같다.


if 조건식:
   실행문1
   실행문2
   …


여기에서 조건식이 참(True)이면 실행문1, 실행문2 … 가 수행되고 그렇지 않으면 실행되지 않는다. 주의할 점은 if 문에 속한 모든 실행문은 들여쓰기가 같아야 한다는 것이다. 한 칸이라도 틀리면 문법 오류를 발생하게 된다. (보통 한 수준의 들여쓰기는 공백문자 4칸으로 한다.) 또한 조건식 뒤의 콜론(:)도 처음에는 빠뜨리기 쉬우니 조심하자.


 조건식에는 보통 관계연산자와 논리연산자가 사용된다.


[표 1] 조건식에서 사용되는 관계/논리 연산자들

분류

연산자들

관계연산자

==, !=, <, >, <=, >=, is, is not, in, not in

논리연산자

and, or, not


예를 들면 다음과 같다.


n = int(input("integer:"))
if n%2==0:
   print("even number!")

#실행:
integer:12
even number!


이 예는 입력 받은 정수가 짝수일 경우 화면에 ‘even number’라고 출력하고 홀수일 경우는 아무런 일도 하지 않는 것이다.


좀 더 일반적인 if 명령의 문법은 else 와 짝을 이루는 것이다.


if 조건식 :
   실행문1
   실행문2
   …
else :
   실행문3
   실행문4
   …


이 경우 조건식이 거짓이면 else 블럭(실행문 3, 실행문4…)을 수행하게 된다.


age = int(input("나이:"))
if age<30:
   print("청년")
else:
   print("중년")

#실행:
나이:44
중년


사용자의 나이 입력을 받아서 나이가 30 미만으면 ‘청년’, 30 이상이면 ‘중년’이라고 출력하는 간단한 예제이다.


 일반적인 if 명령의 구조는 다음과 같다.


if 조건식1 :
   실행문1
   ...
elif 조건식2
   실행문2
   …
elif 조건식3
   실행문3
   …
else :
   실행문n
   …


키워드 elif 는 else if 를 줄인 단어이다. 이 구조에서 조건식1이 참이라면 실행문1을 수행하고 if 블럭을 완전히 빠져나간다. 만약 조건문1이 거짓이라면 조건식2를 판별한다. 그래서 조건식2가 참이면 실행문2를 실행하고 if 블럭을 빠져나간다. 모든 조건이 거짓일 경우 else 문에 속한 실행문n이 실행된다.


s = 'hello'
if 'a' in s:
   print("'a' is contained")
elif 'b' in s:
   print("'b' is contained")
else:
   print("both 'a' and 'b' are not contained")

#실행결과:
both 'a' and 'b' are not contained


파이썬에는 C/C++/JAVA/C# 등에는 있는 switch - case 명령문이 없다. 따라서 비교적 많은 수의 다중 조건을 판단해야 할 경우에도 if - elif- else 문을 조합하여 구성해야 한다.


 가끔 조건문을 판단하고 참 거짓에 따라 행동을 정의 할 때 아무런 일도 하지 않도록 설정을 하고 싶을 때가 생기게 된다. 다음의 예를 보자.


"집에 돈이 있으면 가만히 있고 집에 돈이 없으면 노트북을 팔아라"


위의 예를 pass를 적용해서 구현해 보자.


>>> home = [‘money’, 'TV', 'radio', 'notebook']
>>> if 'money' in home:
...    pass
... else:
...    print("sell notebook.")


home이라는 리스트 안에 'money'라는 문자열이 있기 때문에 if 문 다음 문장인 pass가 수행되었고 아무 일도 수행하지 않는 것을 확인 할 수 있다.


위의 예를 보면 if문 다음의 수행할 문장이 한 줄이고 else문 다음에 수행할 문장도 한 줄이다. 이렇게 수행할 문장이 한 줄일 때 조금 더 간편한 방법이 있다. 위에서 알아본 pass를 사용한 예는 다음처럼 간략화할 수 있다.


>>> home = [‘money’, 'TV', 'radio', 'notebook']
>>> if 'money' in home: pass
... else:
...    print("sell notebook.")


if 문 다음의 수행할 문장을 ':'뒤에 바로 적어 주었다. else 문 역시 마찬가지이다. 이렇게 하는 이유는 때로는 이렇게 하는 것이 보기에 편하게 때문이다.



Posted by 살레시오

댓글을 달아 주세요

 나열형(sequence)은 데이터들의 집합이며 기본적인 나열형 객체는 list, tuple, range 등이다. str형과 bytes형, bytearray 등도 나열형에 속한다. (나열형은 기본적으로 iterable 이다.)


[표 1] 대표적인 가변(mutable) 불변(immutable) 나열형

mutable 시퀀스

immutable 시퀀스

list, bytes, bytearray

str, tuple, range


 다음 표는 가변/불변 나열형 객체에서 지원하는 연산을 우선 순위 차례로 나열한 것이다. x는 임의의 객체이고 s, s1, s2는 나열형 객체들을 표기한다. n, i, j, k는 정수이다.


[표 2] 나열형의 기본 연산의 종류

연산

결과

x in s

x not in s

s의 한 요소가 x와 같다면 True

s의 한 요소가 x와 같다면 False

s1 + s2

s*n 혹은 n*s

두 시퀀스를 결합한다.

시퀀스를 n번 반복한다.

(immutable 시퀀스의 경우 항상 새로운 시퀀스를 생성한다.)

s[i]

i번째 요소 (0부터 시작)

s[i:j]

i번째 부터 j-1번째 요소까지의 슬라이스

s[i:j:k]

i번째 부터 j-1번째 요소까지의(k는 스텝) 슬라이스

len(s)

요소의 개수

min(s)

가장 작은 요소

max(s)

가장 큰 요소

s.index(x[, i[, j]])

x와 같은 첫 번째 요소의 인덱스

s.count(x)

x와 같은 요소들의 개수


같은 형의 나열형 객체끼리는 비교도 가능하다. 특히 리스트와 튜플은 길이와 같은 인덱스를 가지는 모든 요소들끼리 같다면 두 리스트/튜플은 같은 것으로 판별된다.


>>> ‘gg’ in ‘eggs’
True


 나열형 객체의 복사는 ‘얕은 복사’라는 것도 유의해야 한다. 즉, 중첩된 구조는 복사되지 않는다.


>>> lst=[ [] ]*3
>>> lst
[[], [], []]
>>> lst[0].append(1)
>>> lst
[[1], [1], [1]]


이 예제는 곱(*) 복사가 ‘얕은 복사’이기 때문에 원래의 빈 리스트의 참조를 복사해서 붙임을 알 수 있다. 따라서 하나가 변하면 다른 것들도 변한다. 같은 참조를 가지기 때문이다.


서로 다른 리스트를 만들려면 다음과 같이 하면 된다.


lst = [ [] for _ in range(3)]
>>> lst
[[], [], []]
>>> lst[0].append(1)
>>> lst[1].append(2)
>>> lst[2].append(3)
>>> lst
[[1], [2], [3]]


만약 ‘깊은 복사’를 수행하려면 copy 모듈의 deepcopy 함수를 이용하면 된다.


>>> x=[11,22]
>>> y=[x, 33]
>>> y
[[11, 22], 33]
>>> from copy import deepcopy
>>> z = deepcopy(y)
>>> z
[[11, 22], 33]
>>> x[0]=-44
>>> y
[[-44, 22], 33] #x가 변하면 y도 변한다.
>>> z
[[11, 22], 33] # x가 변해도 z는 변함이 없다.


 가변 나열형 객체의 경우 다음과 같은 조작이 추가로 가능하다.


[표 3] 가변 나열형 객체의 조작

연산

결과

s[i] = x

s의 i번째 요소를 x로 교체

s[i:j] = t

i번째 요소부터 j-1번째 요소를 t(iterable)로 교체

del s[i:j]

i번째 요소부터 j-1번째 요소를 삭제 ( s[i:j] = [] 와 동일)

s[i:j:k] = t

i번째 요소부터 j-1번째 요소(k는 스텝)를 t(iterable)로 교체 ➊

del s[i:j:k]

i번째 요소부터 j-1번째 요소(k는 스텝)를 삭제

s.append(x)

s의 마지막 요소로 x를 삽입

s.extend(t)

t의 내용물로 s를 확장 ( s[len(s):len(s)]=t 와 동일)

s.insert(i, x)

i 번째에 x를 삽입

s.pop()

s.pop(i)

마지막 삭제하고 그것을 반환한다.

i 번째 요소를 삭제하고 그것을 반환한다.

s.remove(x)

s의 요소 중 x와 같은 첫 번째 것을 제거 ➋

s.reverse()

요소들을 역순으로 배열한다. ➌

s.clear()

모든 요소 삭제 (del s[:] 과 동일) ver3.3부터 도입

s.copy()

얕은 복사본 생성 (s[:] 와 동일) ver3.3부터 도입


➊ t 와 슬라이싱 된 요소들의 크기가 같아야 한다.

➋ s 안에 x가 없다면 ValueError 예외가 발생한다.

➌ 요소의 순서를 역순으로 바꾼다. ( 역순으로 바뀐 객체가 반환되는 것이 아니다.)



Posted by 살레시오

댓글을 달아 주세요

 딕셔너리에 대해서 사용할 수 있는 메써드는 다음과 같은 것들이 있다. 여기서 d는 딕셔너리 객체를 나타낸다.


[표 1] 딕셔너리의 내장 메소드

소속 함수

기능

d.keys()

d.values()

d.items()

키들을 모아서 dict_keys 객체로 반환한다.

값들을 모아서 dict_values 객체로 반환한다.

(키,값) 튜플을 모아서 dict_items 객체로 반환한다.

d.clear()

모든 키:값 쌍을 제거하고 빈 딕셔너리로 만든다.

d.get(key)

key에 해당하는 값을 가져온다. d[key]와의 차이점은 해당 키가 없을 경우 에러를 발생시킨다는 것이다. (d[key]는 None을 반환함)


여기에서 dict_keys, dict_values, dict_items 객체는 모두 iterable 이다. 따라서 for 문에서 사용할 수 있다. 예를 들면 다음과 같다.


>>> capital = {'kr':'seoul', 'jp':'tokyo', 'cn':'beijing'}
>>> for val in capital.values():
  ...:     print(val)
  ...:     
seoul
beijing
tokyo


만약 이 객체로부터 리스트를 생성할 필요가 있다면 파이썬 내장 함수 list() 를 이용하면 된다.


>>> list( capital.keys() ) # 키들로부터 리스트를 생성한다.


만약 딕셔너리 안에  해당 키가 있는지 조사하려면 in 연산자를 이용한다.


>>> ‘kr’ in capital # ‘kr’이라는 키가 captal 딕셔닐에 있으면 True
True
>>> ‘de’ in capital
False


만약 값을 검색하려면 values() 메써드를 이용해야 한다.


>>> ‘seoul’ in capital.values()
True


 특정 키:값 쌍을 삭제하려면 파이썬 내부 명령어인 del 을 이용하면 된다.


>>> del color[0] # 키가 0인 키-값 쌍을 삭제한다.


리스트, 튜플, 딕셔너리와 같은 자료형은 파이썬 프로그램에서 기본적으로 사용되는 자료형이다. 때문에 확실하게 이해하지 않으면 좋은 프로그램을 작성할 수 없으며 다른 사람의 프로그램도 제대로 이해하기 힘들다.



Posted by 살레시오

댓글을 달아 주세요

 딕셔너리(dictionary)는 키(key)와 그것에 딸린 값(value)의 쌍들의 집합으로 이루어진 자료형이다. 어떤 사람과 관련된 데이터의 예를 들면 ‘name’은 ‘박장현’ , ‘age’가 ‘44’, 등이 있을 것이다. 여기서 ‘name’, ‘age’ 등이 키가 되고 ‘박장현’은 ‘name’이라는 키에 해당되는 값, ‘44’는 ‘age’라는 키에 해당되는 값이다. 이를 파이썬 문법으로 표현하면 다음과 같다.


>>> man1 = {‘name’:’박장현’, ‘age’:44 }


이렇게 입력하면 man1 이라는 딕셔너리가 생성된다. 딕셔너리는 {...}기호로 생성된다. 이와 같이 딕셔너리는 ‘키:값’ 쌍들의 집합이다. 키와 값은 콜론(:)으로 각 쌍은 콤마(,)로 구분한다.


{ key1:val1, key2:val2, …… }


키로 쓸 수 있는 객체는 숫자와 문자열 등 immutable한 객체라면 무엇이든지 사용할 수 있다. 값에 해당하는 것은 어떤 파이썬 객체라도 올 수 있다.


만약 앞의 예에서 man1의 이름에 해당하는 값객체를 얻고 싶다면 다음과 같이 접근할 수 있다.


>>> man1[‘name’]


이것은 man1 딕셔너리의 ‘name’ 키에 해당하는 값객체를 반환한다.


>>> capital = {‘kr’:’seoul’, ‘jp’:’tokyo’, ‘cn’:’beijing’}


이 예에서도 키가 문자열이고 값도 문자열이다. 딕셔너리는 데이터의 저장 ‘순서’라는 개념이 없다. 따라서 내부적인 인덱스는 없으며 오직 ‘키’로만 연결된 ‘값’에 접근할 수 있을 뿐이다.


>>> color = {0:’red’, 1:’yellow’, 2:’white’, 3:’black’}


위의 예도 딕셔너리이지만 이것은 키로 정수를 갖는다. 따라서


>>> color[1] # ‘yellow’ 값을 읽는다.
>>> x = color[0] # x에 문자열 ‘red’가 저장된다.
>>> color[3] = ‘grey’ # 키 3 에 해당하는 값을 변경한다.
>>> color[4] = ‘blue’ #새로운 키-값 쌍을 추가한다.


전술한 바와 같이 딕셔너리는 인덱스가 없다. 이 예제에서 color[1] 과 같은 용례는 인덱싱이 아니라 1이라는 키를 지정해 준 것이므로 혼동하면 안된다. 딕셔너리는 인덱싱도 할 수 없고 슬라이싱도 당연히 허용되지 않는다. 따라서 color[0:2] 같은 사용은 에러를 발생시킨다.


 또 한 가지 주의할 것은 중복된 키는 허용되지 않는다는 것이다.


>>> a={0:'a', 1:'b', 0:'c'}
>>> a
{0: 'c', 1: 'b'}


위 예에서 딕셔너리 a에 0이라는 키가 중복으로 지정되었는데 결과를 보면 하나는 무시되었다. 딕셔너리는 내부 데이터를 키값으로 구별하기 때문에 중복된 키는 허용하지 않는 것이다.


 딕셔너리의 키로 리스트는 사용 불가지만 튜플은 가능하다. 리스트는 mutable 이고 튜플은 immutable이기 때문이다.


>>> a={(1,):'hi', (1,2):'world'}
>>> a
{(1, 2): 'world', (1,): 'hi'}


값에는 어떠한 파이썬 객체도 올 수 있으며 딕셔너리 안에 값으로 딕셔너리가 다시 올 수도 있는 등 중첩도 얼마든지 가능하다.




Posted by 살레시오

댓글을 달아 주세요

튜플(tuple, 터플이라고도 읽는다)은 객체들의 묶음이라는 점에서 리스트와 유사하다. 정의할 때 대괄호 대신 괄호 (..)를 사용한다.


>>> t1 = () # empty tuple 생성
>>> t2 = (11,) # tuple의 요소가 하나일 경우 반드시 끝에 콤마(,)를 붙여야 한다.
>>> t3 = (11, 22)
>>> t4 = (‘abc’, 11, [22, 33])
>>> t5 = ( (11,22), (‘hi’, ‘world’))
>>> t6 = ((True, False))


위에서 빈 튜플을 생성하는 첫 번째 경우만 제외하고 모두 괄호를 생략할 수 있다.


>>> t2 = 11,
>>> t3 = 11, 22
>>> t4 = ‘abc’, 11, [22, 33]
>>> t5 = (11,22), (‘hi’, ‘world’)
>>> t6 = (True, False), # 이 경우 마지막에 콤마가 반드시 붙어야 한다.


이것을 보면 이전에도 몇 번 나왔던 여러 개의 변수를 동시에 생성시키는 경우도 튜플이 사용됨을 알 수 있다.


>>> a, b, c = 11, 22+33j, True # 좌변과 우변 모두 (괄호가 생략된) 튜플이다.


>>> t = 11,22,33 # t는 튜플임
>>> e,f,g = t # e=t[0];f=t[1];g=t[2] 와 같다.
>>> e
11
>>> f
22
>>> g
33


 리스트와의 가장 차이점은 튜플은 그 크기나 개별 요소를 전혀 변경시킬 수 없다는 점이다. 즉, 한 번 생성되고 나면 변경시킬 수 없다. (뒤에서 설명할 immutable sequence 이다.)  튜플도 인덱싱과 슬라이싱이 가능하고 immutable sequence 들의 공통적인 연산(덧셈과 곱셈)이 가능하다.



Posted by 살레시오

댓글을 달아 주세요