160803: 99회차

종료하기 전 티스토리 네이버 로그아웃 할 것

1. 툴

동일

추가시: 

2. 폴더

동일

추가시:

3. 사용할 사이트

동일

추가시:

4. 공부하는 것

다시 파이썬 수업

이걸 눌러서 파이썬 콘솔 활성화 _ 대화형 코딩 가능 (인터액티브 방식)

[05] Python 식별자와 변수선언, 데이터 타입

[01] Python 식별자와 변수선언 - 변수가 동적 자료형

1. 식별자와 변수선언

- 파이썬 언어에서 변수를 정의하려면, 단지 식별자를 사용하여 그 이름을 지으면 된다.

- 식별자란 개체를 식별하는 데 사용되는 이름을 말한다. 

- 파이썬 언어는 변수명을 어떠한 값을 가리키는 이름표로 취급한다. 

- 그것은 값이 어떤 종류인지 따지지 않는다. 따라서 모든 변수는 

  모든 종류의 데이터든 가질 수 있다. 

- 하나의 변수가 프로그램이 살아 움직이는 동안에 서로 다른 데이터 유형으로

  바뀌는 것도 가능하다. 그래서 처음에 정수로 할당되었던 변수가 나중에는 

  문자열을 가질 수도 있다. 

 

*  Python의 식별자 규칙
  - 첫자는 반드시 영문 대소문자 혹은 _(언더바)로 시작
  - 나머지 글자는 영문자, 숫자 혹은 _(언더바)로 구성한다.
  - 대소문자 구분한며, 길이에 대한 제약이 없다.
  - 예약어는 변수로 선언할 수 없다.

* 예약어


 

2. 변수의 선언
 

- 변수는 형이 정해지지 않았으며 어떠한 값이라도 받아들일 수 있는 상태이다. 

- 바로 이 점이 자바와 같이 자료형을 정적으로 유지하는 언어와, 파이썬과 같은 

  동적 언어의 차이점이다. 

- 자바에서는 변수를 생성할 때 자료형을 선언하지만, 파이썬에서는 그렇게 하지 않는다. 

>>> x = 'Hello Jython'

>>> z = 6

>>> y = 3.14

>>> z = z * y

>>> x

>>> Y

>>> z


3. Python의 데이터 타입
-  파이썬에서는 어떤 유형의 데이터를 저장하는지 번역기가 동적인 방식으로 판단한다.


x = 'Hello World'

x = "Hello World Two"

 

# 정수를 정의

y = 10

 

# 부동소수점수

z = 8.75

 

# 복소수

i = 1 + 8.07j

 

>>> # type 함수를 사용하여 개체의 유형을 반환

>>> i = 1 + 8.07j

>>> type(i)

<type 'complex'>

 

>>> a = 'Hello'

>>> type(a)

<type 'str'>

 

>>> x, y, z = 1, 2, 3

>>> print x

1

>>> print z

3

[06] Python 숫자형과 연산자

[01] Python 숫자형과 연산자 

1. 숫자형 

 -  int( 정수), float(실수), complex(복소수)
 - 연산이 가능한 데이터 타입.
 - 변수 선언시 데이터 타입을 선언하지 않는다.

1) 수학연산자

/는 나눗셈시 나머지까지 반환 

//는 나눗셈시 나머지 반환 x 

예시 - 

36/5.0

Out[52]: 7.2

36//5.0

Out[53]: 7.0

 - 나눗셈은 나눗셈의 결과에서 자동적으로 소수점 이하를 버리고 정수를 남긴다.
 - 거듭제곱 연산자는 예상할 수 있듯이, 연산자 왼쪽에 있는 숫자를 n번 곱한 결과를
   반환하며, 연산자 오른쪽의 n은 숫자를 나타낸다.

   >>> #기본적인 수학 계산을 수행
   >>> 10 - 6
    4
    >>> 9 * 7
   63
   >>> 36 // 5
   7
   >>> # 나머지를 반환하는 
   >>> 36 % 5
   1 
   >>> # 5의 제곱 
   >>> 5**2 
   25 
   >>> # 100의 제곱
   >>> 100**2 
   10000

  - 나눗셈의 자동 반올림 안하기 test.py

  # -*- coding:utf-8 -*-

  from __future__ import division

  # 그런 다음 평소와 같이 나눗셈을 수행하면 예상했던 결과를 얻을 수 있다

  print 14/2

  print 14/6

 

2) 수학내장 함수



  >>> # 다음 코드는 수학 내장 함수를 사용하는 몇 가지 예제를 제공한다

>>> # 9의 절대값
>>> abs(9)
9

>>> # -9의 절대값
>>> abs(-9)
9

>>> # 8을 4로 나눈 몫과 나머지로 이루어진 튜플
>>> divmod(8,4)
(2, 0)

>>> # 똑같은 일을 하지만, 이번에는 나머지(모듈로)가 반환됨
>>> divmod(8,3)
(2, 2)

>>> # 8의 제곱을 구함
>>> pow(8,2)
64

>>> # 8의 제곱을 3으로 나눈 나머지  ((8 **2) % 3)
>>> pow(8,2,3)
1
>>> # 반올림을 수행
>>> round(5.67,1)
5.7
>>> round(5.67)
6.00

3) 비교연산자



  >>> # 단순 비교

  >>> 8 > 10
  False

  >>> 256 < 725
 True
 >>> 10 == 10
 True

 >>> # 식 내에서 비교
 >>> x = 2*8
 >>> y = 2
 >>> while x != y:                    <- 저게 세미콜론이 아니라 콜론임 : <- 요거!
 ...     print 'Doing some work...'
 ...     y = y + 2
 ...
 Doing some work...
 Doing some work...
 Doing some work...
 Doing some work...
 Doing some work...
 Doing some work...
 Doing some work...

 >>> # 삼항 비교
 >>> 3<2<3
 False
 >>> 3<4<8
 True

4) 비트연산자



 - 파이썬의 비트 연산자는 숫자를 2의 보수로서 다루는 연산자의 집합이다.
 - 비트 연산자를 사용할 때는, 숫자를 0과 1로 구성된 문자열로 취급한다는 말이다.
 -  2의 보수에 대해 개념을 잡지 못하고 있다면, 위키피디아에서 다음의 문서를 참조한다.
  (http://ko.wikipedia.org/wiki/2의_보수) 비트 연산자는 정수와 긴 정수에만 사용할 수 있다

 >>> 14 & 27 
10
>>> 14 | 27
31
>>> 14 ^ 27
21
>>> ~14
-15
>>> ~27
-28

5) 이동연산자


 - 왼쪽 이동 연산자는 왼쪽 항의 값을 오른쪽 항에서 지정한 비트만큼 왼쪽으로 이동시킨다.
 - 오른쪽 이동 연산자는 정확히 반대로 동작하여, 왼쪽 항의 값을 오른쪽 항에서 지정한 비트만큼
  오른쪽으로 이동시킨다.
- 본질적으로 왼쪽 이동 연산자는 왼쪽에 있는 항에다가 오른쪽 항에서 지정한 횟수만큼
   숫자 2를 곱하는 셈이다. 반대로 오른쪽 이동 연산자는 왼쪽에 있는 항을 오른쪽 항에서
   지정한 횟수만큼 2로 나누는 것이다.


  # 왼쪽으로 이동, 여기서는 3*2

  >>> 3<<1
 6
 # 3*2*2와 동등함
 >>> 3<<2
 12
 # 3*2*2*2*2*2와 동등함
 >>> 3<<5
 96
 # 오른쪽으로 이동
 # 3/2와 동등함
 >>> 3>>1
 1
 # 9/2와 동등함
 >>> 9>>1
 4
 # 10/2와 동등함
 >>> 10>>1
 5
 # 10/2/2와 동등함
 >>> 10>>2
 2

6) 복합대입연산자

  >>> x = 5 
  >>> x
  5
  # x의 값에 1을 더하여 그 값을 x에 할당
  >>> x+=1
  >>> x
  6
  # x의 값에 5를 곱하여 그 값을 x에 할당
  >>> x*=5
  >>> x
  30

 

[07] Python 논리형, 문자열, 형변환 함수

[01] Python 논리형, 문자열, 형변환 함수

1. 논리형

 - 부울 값을 표현하기 위해 0과 1을 써서도 쉽게 작성할 수는 있겠지만,
 - 가독성과 유지보수를 위해서 True와 False
 - 첫자는 대문자로 쓴다.

조건부	논리
and	x and y 평가에 있어서, x가 거짓으로 판명되면 그것을 반환하고, 그렇지 않은 경우에는 y를 평가하여 결과값을 반환
or	x or y 평가에 있어서, x가 참으로 판명되면 그것을 반환하고, 그렇지 않은 경우에는 y를 평가하여 결과값을 반환
not	not x 평가에 있어서, x가 거짓이라는 것은 x의 반대를 의미함

2. 문자열
 
  - 여러문자로 구성도어 있고, 다른 문자와 연결될 수 있으며 데이터에 포함된
    문자열의 길이를 확인할 수 있는 데이터 타입(str)

  - ('), (")로 감싸면 문자열로 인식한다. (' ' '), (" " ")로 감싸면 여러 줄인 경우에 사용된다.

   # -*- coding:utf-8 -*-

   print("안녕하세요")

   print('안녕하세요')
 

   print('''                            - '가 3개임

        안녕하세요

        반갑습니다.

        다시봅시다.

   ''')

    
     print(' 안녕하세요\n'
                   '반갑습니다.\n'

          '다시봅시다.')
 

   - 문자열 중간에 (') 출력하기

    print(" 안녕하세요 \"홍길동 \" 입니다.")
    print(' 안녕하세요 \'홍길동\' 입니다.')
    print(" 안녕하세요 '김길동' 입니다.")
    print(' 안녕하세요 "박길동" 입니다.')


  - 문자열 메소드 사용하기 

>>> our_string='python is the best language ever'

 

>>> # 문자열의 첫 글자를 대문자로

>>> our_string.capitalize()

'Python is the best language ever'

 

>>> # 가운데 정렬

>>> our_string.center(50)

'         python is the best language ever         '

>>> our_string.center(50,'-')

'---------python is the best language ever---------'

 

>>> # 문자열 내에서 부분문자열 세기

>>> our_string.count('a')

2

 

>>> # 부분문자열 발생 횟수 세기

>>> state = 'Mississippi'

>>> state.count('ss')

2

 

>>> # 문자열을 분할(partition)하면, 분리자의 앞 부분, 분리자, 그리고 그 분리자의

>>> # 뒷 부분의 세 원소로 이루어진 튜플을 반환

>>> x = "Hello, my name is Josh"

>>> x.partition('n')

('Hello, my ', 'n', 'ame is Josh')

 

>>> # 위와 똑같은 x가 있다고 할 때, 'l'을 분리자로 하여 문자열을 쪼개기(split)

>>> x.split('l')

['He', '', 'o, my name is Josh']

 

>>> # 보는 바와 같이 분리자는 반환되는 목록에 포함되지 않는다.

>>> # maxsplits 값을 1로 하여 추가하게 되면, 가장 왼쪽부터 쪼개기가 이루어진다.

>>> # maxsplits 값을 2로 주면, 가장 왼쪽 두 개의 쪼개기가 이루어진다.

>>> x.split('l',1)

['He', 'lo, my name is Josh']

>>> x.split('l',2)

['He', '', 'o, my name is Josh']

 

3. 형 변환 함수

함수	설명
chr(value)	정수를 문자로 변환
complex(real [,imag])	복소수를 만듦
dict(sequence)	주어진 (키, 값) 튜플의 순서로부터 사전을 만듦
eval(string)	문자열을 평가하여 수학적 계산에 유용한 개체를 반환. 주의: 이 함수는 올바로 사용하지 않을 경우 보안 위험을 초래할 수 있으므로 매우 조심하여야 함
float(value)	숫자를 부동소수점수로 변환
frozenset(set)	집합을 동결집합으로 변환
hex(value)	정수로부터 16진수를 나타내는 문자열로 변환
int(value [, base])	정수로 변환하며 base 문자열이 주어진 경우에는 사용함
list(sequence)	주어진 순서를 목록으로 변환
long(value [, base])	long(긴 정수)형으로 변환하며 base 문자열이 주어진 경우에는 사용함
oct(value)	정수로부터 8진수를 나타내는 문자열로 변환
ord(value)	문자를 가리키는 정수값으로 변환
repr(value)	개체를 표현 문자열로 변환. 표현식을 역따옴표로 둘러싼 것과 같음(`x + y`). 개체에 대하여 출력가능하며평가 가능한 문자열을 반환
set(sequence)	sequence를 집합으로 변환
str(value)	개체를 문자열로 변환. value에 대하여 출력가능한 문자열을 반환 하나, 평가할 수는 없음
tuple(sequence)	주어진 sequence를 튜플로 변환
unichr(value)	정수를 유니코드 문자로 변환

# 정수가 나타내는 문자를 반환

>>> chr(4)

'\x04'

>>> chr(10)

'\n'

 

>>> # 정수를 부동소수점수로 변환

>>> float(8)

8.0

 

>>> # 문자를 나타내는 정수 값으로 변환

>>> ord('A')

65

>>> ord('C')

67

>>> ord('z')

122

 

>>> # 임의의 개체에 대하여 repr()을 사용

>>> repr(3.14)

'3.14'

>>> x = 40 * 5

>>> y = 2**8

>>> repr((x, y, ('one','two','three')))

"(200, 256, ('one', 'two', 'three'))"

[08] Python 데이터구조 list, tuple, set, Dictionary

[01] Python 데이터구조 list, tuble, set, Dictionary

- 데이터구조란 

  데이터를 활용 방식에 따라 조금 더 효율적으로 이용할 수 있도록 

  컴퓨터에 저장하는 여러 방법들

- Python의 데이터 구조는 list, tuble, set, Dictionary
 

1. list

  - 파이썬 프로그래밍 언어 내에서 가장 많이 쓰이는 구조

  - 목록은 어떠한 파이썬 자료형이라도 저장할 수 있다.

 

  >>> # 빈 목록을 정의

  >>> my_list = []

  >>> my_list = list()  # 가끔 사용됨

 

  >>> # 하나의 원소를 가진 목록

  >>> my_list = [1]

  >>> my_list  # 번역기에서 변수를 출력하기 위해서 print를 사용할 필요가 없다

     [1]

 

  >>> # 문자열 값의 목록을 정의

  >>> my_string_list = ['Hello', 'Jython' ,'Lists']

  >>> # 복수의 자료형을 포함하는 목록을 정의

  >>> multi_list = [1, 2, 'three', 4, 'five', 'six']

  >>> # 목록을 포함하는 목록을 정의

  >>> combo_list = [1, my_string_list, multi_list]

  >>> # 목록을 포함하는 목록을 한 줄로 정의

  >>> my_new_list = ['new_item1', 'new_item2', [1, 2, 3, 4], 'new_item3']

  >>> print my_new_list

  ['new_item1', 'new_item2', [1, 2, 3, 4], 'new_item3']

 

  >>> # 목록에서 원소를 얻기

  >>> my_string_list[0]

  'Hello'

  >>> my_string_list[2]

  'Lists'

 

  >>> # 음수 인덱스는 목록의 마지막 원소에서 시작하여 첫 항목 쪽으로 거슬러 감

  >>> my_string_list[-1]

  'Lists'

  >>> my_string_list[-2]

  'Jython'

 

  >>> # 썰기(썰기는 시작 인덱스의 원소는 포함하고 끝 인덱스의 원소는 제외한다는 점에 유의)

  >>> my_string_list[0:2]

  ['Hello', 'Jython']

 

  >>> # 썰기를 통해 목록의 얕은 사본을 생성

  >>> my_string_list_copy = my_string_list[:]

 

  >>> my_string_list_copy

  ['Hello', 'Jython', 'Lists']

 

  >>> # 목록에서 모든 다른 원소를 반환

  >>> new_list=[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

  >>> # 시작인덱스:끝인덱스:간격

  >>> # 이 예제는 한 칸 씩 이동(step)

  >>> new_list[0:10:1]

  [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

 

  >>> # 그리고 여기서는 두 칸 씩 이동

  >>> new_list[0:10:2]

  [2, 6, 10, 14, 18]

 

  >>> # 시작 인덱스를 비워두면 기본값이 0을 지정한 것과 같이 동작하며, 

  >>< # 끝 인덱스에 대해서는 목록의 길이가 기본값임

  >>> new_list[::2]

  [2, 6, 10, 14, 18]
 

  >>> # 목록의 원소를 수정. 이 경우는 9번 위치에 있는 원소를 수정함

  >>> new_list[9] = 25

  >>> new_list

  [2, 4, 6, 8, 10, 12, 14, 16, 18, 25]

 

  >>> # append 메소드를 사용하여 목록에 값들을 추가

  >>> new_list=['a','b','c','d','e','f','g']

  >>> new_list.append('h')

  >>> print new_list

  ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

 

  >>> # 다른 목록을 기존 목록에 추가

  >>> new_list2=['h','i','j','k','l','m','n','o','p']

  >>> new_list.extend(new_list2)

  >>> print new_list

  ['a', 'b', 'c', 'd', 'e', 'f', 'g', ‘h’,'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']

 

  >>> # 인덱스를 통해 특정 위치에 값을 삽입.

  >>> # 이 예제에서는 'c'를 목록에서 3 번째 위치에 추가

  >>> # (목록의 인덱스는 0부터 시작하므로, 인덱스 2가 실제로는 세번째 자리를 가리킴을 기억하라)

  >>> new_list.insert(2,'c')

  >>> print new_list

  ['a', 'b', 'c', 'c', 'd', 'e', 'f', 'g', 'h', ‘h’,'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']

 

  >>> # 인덱스를 통해 특정한 위치로 목록을 삽입

  >>> another_list = ['a', 'b', 'c']

  >>> another_list.insert(2, new_list)

  >>> another_list

  ['a', 'b', [2, 4, 8, 10, 12, 14, 16, 18, 25], 'c']

 

  >>> # 썰기 표기법을 사용하여 목록 또는 순서의 일부를 덮어씀

  >>> new_listA=[100,200,300,400]

  >>> new_listB=[500,600,700,800]

  >>> new_listA[0:2]=new_listB

  >>> print new_listA

  [500, 600, 700, 800, 300, 400]

 

  >>> # 빈 썰기 표기법을 사용하여 목록을 다른 목록에 할당

  >>> one = ['a', 'b', 'c', 'd']

  >>> two = ['e', 'f']

  >>> one

  ['a', 'b', 'c', 'd']

  >>> two

  ['e', 'f']

 

  >>> # 시작과 종료 위치를 동일하게 하여 목록으로부터 빈 조각을 만들어낸다.

  >>> # 시작과 끝 위치를 동일하게 쓰는 한, 어느 위치든 상관 없음.

  >>> one[2:2]

  []

 

  >>> # 그 자체로는 별로 재미가 없다 - 빈 목록은 아주 쉽게 만들 수 있다.

  >>> # 이것에 대해 유용한 점은 이것을 빈 조각에 할당할 수 있다는 것이다.

  >>> # 이제, 'two' 목록을 'one'목록의 빈 조각에 할당함으로써 실제로는 'two' 목록을 'one' 목록에 삽입한다.

  >>> one[2:2] = two          # 'one' 목록의 원소 1과 2 사이를 'two' 목록으로 대체

  >>> one

  ['a', 'b', 'e', 'f', 'c', 'd']

 

  >>> # del 구문을 사용하여 값 또는 값의 범위를 목록으로부터 제거

  >>> # 모든 다른 원소가 이동하여 빈 공간을 채움에 유의

  >>> new_list3 = ['a','b','c','d','e','f']

  >>> del new_list3[2]

  >>> new_list3

  ['a', 'b', 'd', 'e', 'f']

  >>> del new_list3[1:3]

  >>> new_list3

  ['a', 'e', 'f']

 

  >>> # del 구문을 사용하여 목록을 제거

  >>> new_list3=[1,2,3,4,5]

  >>> print new_list3

  [1, 2, 3, 4, 5]

  >>> del new_list3

  >>> print new_list3

  Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

  NameError: name 'new_list3' is not defined

 

  >>> # pop과 remove 함수를 사용하여 목록으로부터 값을 제거

  >>> print new_list

  ['a', 'b', 'c', 'c', 'd', 'e', 'f', 'g', 'h',’h’, 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']

 

  >>> # 인덱스가 2인 원소를 pop

  >>> new_list.pop(2)

  'c'

  >>> print new_list

  ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',’h’, 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']

 

  >>> # 목록에서 처음으로 나타나는 'h' 문자를 제거

  >>> new_list.remove('h')

  >>> print new_list

  ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']

 

  >>> # pop() 함수를 사용하는 유용한 예제

  >>> x = 5

  >>> times_list = [1,2,3,4,5]

  >>> while times_list:

  ...      print x * times_list.pop(0)

  ...

     5

    10

    15

    20

     25

꺼내온 뒤에 내용 없어짐(pop)


 2. list 함수 사용하기 

 


>>> # 어떤 주어진 값에 대한 인덱스를 반환

>>> new_list=[1,2,3,4,5,6,7,8,9,10]

>>> new_list.index(4)

3

 

>>> #  인덱스가 4인 원소의 값을 변경

>>> new_list[4] = 30

>>> new_list

[1, 2, 3, 4, 30, 6, 7, 8, 9, 10]

 

>>> # 이제, 값을 원상태로 되돌려놓자.

>>> new_list[4] = 5

>>> new_list

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

>>> # 이 목록에 중복된 값을 추가하고 인덱스를 반환

>>> # 처음 나타나는 값의 인덱스를 반환함에 유의

>>> new_list.append(6)

>>> new_list

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 6]

>>> new_list.index(6)

5

 

>>> # 주어진 값과 동등한 원소의 갯수를 반환하도록 count() 함수를 사용

>>> new_list.count(2)

1

>>> new_list.count(6)

2

 

>>> # 목록의 값들을 정렬

>>> new_list.sort()

>>> new_list

[1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 10]

 

>>> # 목록의 값들의 순서를 반대로

>>> new_list.reverse()

>>> new_list

[10, 9, 8, 7, 6, 6, 5, 4, 3, 2, 1]

3. tuple 

 - 변경할 수 없는 lit형

 - list형은 일반적으로 동일한 자료형으로 이루어진 항목들을

   list내에서 순차적으로 추출하는 용도로 사용되는 반면

 - tuple형은 서로다른 종류의 데이터형으로 이루어진 항목들을

   바로 풀어쓰는 언패킹 또는 색인을 매기는 용도로 사용한다.

 - []아닌 ()기호로 감싸거나 아예 감싸지 않는 방법으로 선언한다.

 

>>> # 빈 튜플 생성

>>> myTuple = ()

 

>>> # 튜플 생성하고 사용하기

>>> myTuple2 = (1, 'two',3, 'four')

>>> myTuple2

(1, 'two', 3, 'four')

 

>>> # 마지막에 쉼표를 써서 한 항목짜리 튜플을 생성하기

>>> myteam = 'Bears',

>>> myteam

('Bears',)

 

 - tuple은 변경할 수 없는 자료형(Immutable)이지만 튜폴항목의 

   list데이터 형은 변경이 가능한 데이터형이라면 해당 객체 내의

   변경이 가능하다.

 

 >>>t2 = [1,2,3],[4,5,6]

 >>>t2

 ([1, 2, 3], [4, 5, 6])

 >>>t2[0]

 [1, 2, 3]

 >>>t2[0] = [7,8,9]

Traceback (most recent call last):

  File "C:\Users\lecture\AppData\Local\Enthought\Canopy\User\lib\site-packages\IPython\core\interactiveshell.py", line 2885, in run_code

    exec(code_obj, self.user_global_ns, self.user_ns)

  File "<ipython-input-56-28c2e5ed8f80>", line 1, in <module>

    t2[0] = [7,8,9]

TypeError: 'tuple' object does not support item assignment

 >>>t2[0][0] = 7

 t2

 ([7, 2, 3], [4, 5, 6])

 

 - 변수 movie에 4개의 서로 다른 자료형이 하나의 튜풀로 포장되었다.

   이개념 튜플패키징이라고 하다.

 >>>movie ='슈퍼맨',1234,'배트면',4321

 >>>movie

 

 - 반대로 아래 예제 처럼 튜플을 항목별로 각각 풀어서 할당하는 개념을 튜플 

   언패킹이라고 한다.

 >>>a,b,c,d = movie

 >>>a

 >>>b

 >>>c

 >>>d

 

4. SET 

 - 색인에 대한 순서가 없고 중복이 허용되지 않는 데이터들의 집합

 - set()함수로만 set생성이 가능하다.

 

>>> # 집합을 사용하기 위해서는 우선 모듈을 들여와야한다.

>>> from sets import Set

 

>>> # 다음의 구문을 써서 집합을 생성한다

>>> myset = Set([1,2,3,4,5])

>>> myset

Set([5, 3, 2, 1, 4])

 

>>> # 집합에 값을 추가. 자세한 내용은 표 2-7을 참조

>>> myset.add(6)

>>> myset

Set([6, 5, 3, 2, 1, 4])

 

>>> # 중복되는 원소의 추가를 시도

>>> myset.add(4)

>>> myset

Set([6, 5, 3, 2, 1, 4])

 

>>> # 두 개의 집합을 생성

>>> s1 = Set(['jython','cpython','ironpython'])

>>> s2 = Set(['jython','ironpython','pypy'])

 

>>> # 집합의 사본을 만듦

>>> s3 = s1.copy()

>>> s3

Set(['cpython', 'jython', 'ironpython'])

 

>>> # s1에는 속하지만 s2에는 속하지 않는 모든 원소를 포함하는 새로운 집합을 구함

>>> s1.difference(s2)

Set(['cpython'])

 

>>> # 각 집합의 모든 원소를 포함하는 새로운 집합을 구함

>>> s1.union(s2)

Set(['cpython', 'pypy', 'jython', 'ironpython'])

 

>>> # 각 집합에 속하되 양쪽 모두에는 속하지 않는 원소로 이루어진 새로운 집합을 구함

>>> s1.symmetric_difference(s2)

Set(['cpython', 'pypy'])

 

>>> # 세 개의 집합을 생성

>>> s1 = Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

>>> s2 = Set([5, 10, 15, 20])

>>> s3 = Set([2, 4, 6, 8, 10])

 

>>> # s2로부터 임의의 원소를 제거

>>> s2.pop()

20

>>> s2

Set([5, 15, 10])

 

>>> # s1에 3과 동일한 원소가 존재하는 경우 폐기

>>> s1.discard(3)

>>> s1

Set([6, 5, 7, 8, 2, 9, 10, 1, 4])

 

>>> # s1과 s2 양쪽 모두에 속하는 원소들만을 가지도록 s1을 갱신

>>> s1.intersection_update(s2)

>>> s1

Set([5, 10])

>>> s2

Set([5, 15, 10])

 

>>> # s2의 모든 원소를 제거

>>> s2.clear()

>>> s2

Set([])

 

>>> # 집합 s3의 모든 원소를 포함하도록 s1을 갱신

>>> s1.update(s3)

>>> s1

Set([6, 5, 8, 2, 10, 4])

5. Dictionary

- 전체항목이 정렬되지 않는 키(key)와 값(Value)의 쌍으로 구성된 집합

 

>>> # 빈 사전 및 채워진 사전을 생성

>>> myDict={}

>>> myDict.values()

[]

 

>>> # 사전에 열쇠-값 쌍을 할당

>>> myDict['one'] = 'first'

>>> myDict['two'] = 'second'

>>> myDict

{'two': 'second', 'one': 'first'}

 

>>> # 빈 사전을 생성하고 사전을 채움

>>> mydict = {}

 

>>> # 사전에서 열쇠를 찾아봄

>>> 'firstkey' in mydict

False

 

>>> # 사전에 열쇠/값 쌍을 추가

>>> mydict['firstkey'] = 'firstval'

>>> 'firstkey' in mydict

True

 

>>> # 사전의 값들을 나열

>>> mydict.values()

['firstval']

 

>>> # 사전의 열쇠들을 나열

>>> mydict.keys()

['firstkey']

 

>>> # 사전의 길이(열쇠/값 쌍이 얼마나 들어있는지)를 표시

>>> len(mydict)

1

 

>>> # 사전의 내용을 출력

>>> mydict

{'firstkey': 'firstval'}

 

>>> # 원본 사전을 문자열 기반 열쇠를 가진 사전으로 대체

>>> # 다음의 사전은 하키 팀을 표현

>>> myDict = {'r_wing':'Josh','l_wing':'Frank','center':'Jim','l_defense':'Leo','r_defense':'Vic'}

>>> myDict.values()

['Josh', 'Vic', 'Jim', 'Frank', 'Leo']

>>> myDict.get('r_wing')

'Josh'

>>> myDict['r_wing']

'Josh'

 

>>> # 존재하지 않는 열쇠에 대한 값을 얻기 위해 시도

>>> myDict['goalie']

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 'goalie'

 

>>> # get()을 사용하여 존재하지 않는 열쇠에 대한 값을 얻기 시도

>>> myDict.get('goalie')p

>>>

 

>>> # 열쇠가 존재하지 않는 경우 기본 메시지를 표시

>>> myDict.get('goalie','Invalid Position')

'Invalid Position'

 

>>> # 사전의 항목들에 대하여 반복

>>> for player in myDict.iteritems():

...     print player

...

('r_wing', 'Josh')

('r_defense', 'Vic')

('center', 'Jim')

('l_wing', 'Frank')

('l_defense', 'Leo')

 

>>> # 열쇠와 값을 독립적인 개체에 할당한 다음 출력

>>> for key,value in myDict.iteritems():

...     print key, value

...

r_wing Josh

r_defense Vic

center Jim

l_wing Frank

l_defense Leo

 

5. 수업

진도: 

hw: 

6. 할것