python tutorial -5 자료 구조

python tutorial

part 5

자료 구조 データ構造

 

https://docs.python.org/ko/3/tutorial/datastructures.html

 

 

---

5.1. 리스트 더 보기リスト型についてもう少し

 

리스트 메소드 リストデータ型 メソッド

 

list.append(x)

    리스트의 끝에 항목을 더함

    a[len(a):] = [x]

    リストの末尾に要素を一つ追加します。

a[len(a):] = [x] と等価です。

 

list.extend(iterable)

리스트의 끝에 이터러블의 모든 항목을 덧붙여서 확장

a[len(a):] = iterable

    

イテラブルのすべての要素を対象のリストに追加し、リストを拡張します。

a[len(a):] =iterable と等価です。

 

list.insert(i, x)

주어진 인덱스에 항목을 삽입

a.insert(0, x) 는 리스트의 처음에 삽입

a.insert(len(a), x) = a.append(x)

 

指定した位置に要素を挿入します。

第 1 引数は、リストのインデクスで、そのインデクスを持つ要素の直前に挿入が行われます。

a.insert(0, x) はリストの先頭に挿入を行います。

a.insert(len(a), x) は a.append(x) と等価です。

 

list.remove(x)

리스트에서 값 x 첫 번째 항목을 삭제

항목이 없으면 ValueError

リスト中で x と等しい値を持つ最初の要素を削除します。

該当する要素がなければ ValueError が送出されます。

 

list.pop([i])

주어진 인덱스의 값을 빼옴 (값을 가져오며 삭제함)

인덱스를 지정하지 않은 a.pop()은 마지막 항목을 pop함

 

([i] : 매개변수가 선택적임을 표현.

그 위치에 꺾쇠괄호를 입력해야 한다는 뜻이 아닙니다.

이 표기법은 파이썬 라이브러리 레퍼런스에서 자주 등장합니다.)

 

リスト中の指定された位置にある要素をリストから削除して、その要素を返します。

インデクスが指定されなければ、 a.pop() はリストの末尾の要素を削除して返します。

この場合も要素は削除されます。

 

(メソッドの用法 (signature) で i の両側にある角括弧は、

この引数がオプションであることを表しているだけなので、角括弧を入力する必要はありません。

この表記法は Python Library Reference の中で頻繁に見ることになるでしょう。)

 

list.clear()

    리스트의 모든 항목을 삭제

    del a[:]

    リスト中の全ての要素を削除します。del a[:] と等価です。

 

list.index(x[,start[,end]])

첫번째 x의 인덱스를 구함

항목이 없으면 ValueError

선택 인자 start 와 end 는 슬라이스 표기법처럼 해석

검색을 리스트의 특별한 서브 시퀀스로 제한하는 데 사용

돌려주는 인덱스는 start 인자가 아니라 전체 시퀀스의 시작을 기준

 

リスト中で x と等しい値を持つ最初の要素の位置をゼロから始まる添字で返します。

該当する要素がなければ ValueError が送出されます。

 

任意の引数である start と end はスライス記法として解釈され、リストの探索範囲を指定できます。

返される添字は、start 引数からの相対位置ではなく、リスト全体の先頭からの位置になります。

 

list.count(x)

리스트에서 x가 등장하는 횟수를 돌려줍니다.

リストでの x の出現回数を返します。

 

list.sort(key=None, reverse=False)

리스트의 항목들을 정렬

リストの項目を、インプレース演算でソートします。(in place、元のデータを演算結果で置き換えるやりかた)

 

list.reverse()

리스트의 요소들을 제자리에서 뒤집습니다.

リストの要素を、インプレース演算で逆順にします。

 

list.copy()

리스트 사본을 돌려줍니다. a[:]

リストの浅い (shallow) コピーを返します。a[:] と等価です。

ex)

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'

 

 

insert, remove, sort 메소드 : 

리스트를 수정할 뿐 / 출력 x

기본 None값 반환

 

insert, remove, sort などのリストを操作するメソッドの戻り値が表示されていないことに気が付いたかもしれません。

これらのメソッドは None を返しています。

 

 

다른 언어들에서는 가변 객체를 돌려주기도 하는데,  d->insert("a")->remove("b")->sort(); 와 같은 메서드 연쇄를 허락합니다.

他の言語では変更可能なオブジェクトを返して、d->insert("a")->remove("b")->sort(); のようなメソッドチェインを許している場合もあります。

 

 

이것은 파이썬에서 모든 가변 자료 구조들에 적용되는 설계 원리입니다.

これは Python の変更可能なデータ構造全てについての設計上の原則となっています。

 

 

---

5.1.1. 리스트를 스택으로 사용하기 リストをスタックとして使う

스택 - "last-in, first-out"

스택의 꼭대기에 값 넣기 : append()

스택의 꼭대기에서 값 꺼내기 : pop()

 

リスト型のメソッドのおかげで、簡単にリストをスタックとして使えます。

スタックでは、最後に追加された要素が最初に取り出されます ("last-in, first-out")。

    スタックの一番上に要素を追加するには append() を使います。

    スタックの一番上から要素を取り出すには pop() をインデクスを指定せずに使います。

 

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

 

---

5.1.2. 리스트를 큐로 사용하기 リストをキューとして使う

 

큐 - "first-in, first-out"

    리스트는 큐에 효율적이지 않음

 

リストをキュー (queue) として使うことも可能です。

この場合、最初に追加した要素を最初に取り出します ("first-in, first-out")。

しかし、リストでは効率的にこの目的を達成することが出来ません。

 

리스트의 끝에 값을 넣고 빼는 것은 빠르지만,

리스트의 처음에 값을 넣고 빼는 것은 느림

- 뒤 값들을 모두 한 칸씩 앞으로 이동시켜야 하기 때문

 

追加（append）や取り出し（pop）をリストの末尾に対して行うと速いのですが、

挿入（insert）や取り出し（pop）をリストの先頭に対して行うと遅くなってしまいます。

（他の要素をひとつずつずらす必要があるからです）

 

 

큐 구현 

collections.deque  사용 

추가 : .append(값)

빼기 : .popleft(값)

 

キューの実装には、 collections.deque を使うと良いでしょう。

このクラスは良く設計されていて、高速な追加（append）と取り出し（pop）を両端に対して実現しています。

 

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

 

---

5.1.3. 리스트 컴프리헨션 リストの内包表記

 

리스트 컴프리헨션 : 간단히 리스트를 만드는 방법

リスト内包表記はリストを生成する簡潔な手段を提供しています。

 

    - 각 요소에 연산 결과 리스트 생성

    - 조건을 만족하는 서브 시퀀스 생성

 

主な利用場面は、

あるシーケンスや iterable (イテレート可能オブジェクト) のそれぞれの要素に対してある操作を行った結果を要素にしたリストを作ったり、

ある条件を満たす要素だけからなる部分シーケンスを作成することです。

 

 

ex) 

제곱수의 리스트 만들기

次のような平方のリストを作りたいとします:

 

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

 

변수 x 생성, for문이 끝나도 남아있음

これはループが終了した後にも存在する x という名前の変数を作る (または上書きする) ことに注意してください。

 

 

간결하게

以下のようにして平方のリストをいかなる副作用もなく計算することができます:

 

squares = list(map(lambda x: x**2, range(10)))

 

더 간결하게

squares = [x**2 for x in range(10)]

 

 

리스트 컴프리헨션

구성 :  = [for / if 문]

결과 : 새 리스트.

for 와 if 절의 문맥에서 표현식의 값을 구해서 만들어집니다.

これはより簡潔で読みやすいです。

リスト内包表記は、括弧の中の 式、 for 句、そして0個以上の for か if 句で構成されます。 

リスト内包表記の実行結果は、 for と if 句のコンテキスト中で式を評価した結果からなる新しいリストです。

 

 

ex) 

두 리스트 항목의 서로 같지 않은 것끼리 결합

例えば、次のリスト内包表記は2つのリストの要素から、違うもの同士をペアにします。

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

=

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

 

 for 와 if 문의 순서가 같음

        표현식이 튜플이면 (즉 앞의 예에서 (x, y)), 반드시 괄호로 둘러싸야 함.

 

for と if 文が両方のコードで同じ順序になっていることに注目してください。

式がタプルの場合 (例: 上の例で式が (x, y) の場合) は、タプルに円括弧が必要です。

 

>>> vec = [-4, -2, 0, 2, 4]
>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # create a list of 2-tuples like (number, square)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)]
  File "<stdin>", line 1, in <module>
    [x, x**2 for x in range(6)]
               ^
SyntaxError: invalid syntax
>>> # flatten a list using a listcomp with two 'for'
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

 

 

 

리스트 컴프리헨션은 복잡한 표현식과 중첩된 함수들을 포함할 수 있습니다:

リスト内包表記の式には、複雑な式や関数呼び出しのネストができます:

 

>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

 

 

 

---

5.1.4. 중첩된 리스트 컴프리헨션 ネストしたリストの内包表記

 

리스트 컴프리헨션의 첫 표현식으로 임의의 표현식이 올 수 있는데, 다른 리스트 컴프리헨션도 가능합니다.

リスト内包表記中の最初の式は任意の式なので、そこに他のリスト内包表記を書くこともできます。

 

3x4 행렬

次の、長さ4のリスト3つからなる、3x4 の matrix について考えます:

 

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]

 

행과 열 전치

次のリスト内包表記は、matrix の行と列を入れ替えます:

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

 

 

중첩된 리스트 컴프리헨션은 뒤 for의 문맥에서 값이 구해집니다.

前の節で見たように、ネストしたリスト内包表記は、続く for のコンテキストの中で評価されます。

なので、この例は次のコードと等価です:

 

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

 

=

>>> transposed = []
>>> for i in range(4):
...     # the following 3 lines implement the nested listcomp
...     transposed_row = []
...     for row in matrix:
...         transposed_row.append(row[i])
...     transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

 

 

실제, 복잡한 흐름 문보다 내장 함수들을 선호해야 합니다.

実際には複雑な流れの式よりも組み込み関数を使う方が良いです。

 zip() 함수

この場合 zip() 関数が良い仕事をしてくれるでしょう:

 

>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

 

---

5.2. del 문 del 文

 

del 문: 

리스트에서 인덱스로 항목을 삭제

이것은 값을 돌려주는 pop()과 다름!

슬라이스로 삭제하거나 전체 리스트를 비우는 데도 사용 (빈 리스트를 슬라이스에 대입)

リストから要素を削除する際、値を指定する代わりにインデックスを指定する方法があります。

それが del 文です。これは pop() メソッドと違い、値を返しません。

 

del 文はリストからスライスを除去したり、

リスト全体を削除することもできます(以前はスライスに空のリストを代入して行っていました)。

 

 

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

 

 

 

del 는 변수를 삭제 함

del は変数全体の削除にも使えます:

 

>>> del a

 

삭제 후 a 를 참조하는 것은 에러 (적어도 다른 값이 새로 대입되기 전까지).

この文の後で名前 a を参照すると、(別の値を a に代入するまで) エラーになります。

 

 

---

5.3. 튜플과 시퀀스 タプルとシーケンス

 

리스트와 문자열 

- 인덱싱과 슬라이싱 연산과 같은 많은 성질을 공유함

- 시퀀스 자료 형 : list, tuple, range, string

 

リストや文字列には、インデクスやスライスを使った演算のように、数多くの共通の性質があることを見てきました。

これらは シーケンス (sequence) データ型 (シーケンス型 --- list, tuple, range を参照) の二つの例です。

 

튜플

시퀀스 자료 형

쉼표로 구분되는 여러 값으로 구성

 

Python はまだ進歩の過程にある言語なので、他のシーケンスデータ型が追加されるかもしれません。

標準のシーケンス型はもう一つあります: タプル (tuple) 型です。

タプルはコンマで区切られたいくつかの値からなります。

 

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

 

튜플 

출력 : 항상 괄호 - 중첩 튜플을 올바르게 해석 가능

입력 : 괄호없이도 가능 (튜플이 더 큰 표현식 이면 괄호 필요)

 

튜플 개별항목에 값 대입 : 불가능

리스트 같은 가변 객체를 포함하는 튜플은 만들 수 있음.

 

ご覧のとおり、タプルの表示には常に丸括弧がついていて、タプルのネストが正しく解釈されるようになっています。

タプルを書くときは必ずしも丸括弧で囲まなくてもいいですが、(タプルが大きな式の一部だった場合は) 丸括弧が必要な場合もあります。

タプルの要素を代入することはできません。

しかし、タプルにリストのような変更可能型を含めることはできます。

 

 

튜플 vs 리스트

タプルはリストと似ていますが、たいてい異なる場面と異なる目的で利用されます。

 

튜플

불변 (immutable)

다른 종류의 요소들

タプルは不変型 (immutable) で、複数の型の要素からなることもあり

 

요소들은 언 패킹이나 인덱싱으로 액세스 가능 (네임드튜플은 어트리뷰트로도 가능)

要素はアンパック操作やインデックスでアクセスすることが多いです。(namedtuples の場合は属性)

 

리스트

가변 (mutable)

같은 종류의 요소들

리스트에 대한 이터레이션으로 액세스

 

一方、リストは変更可能 (mutable) で、要素はたいてい同じ型のオブジェクトであり、

たいていイテレートによってアクセスします。

 

 

항목이 0개 / 1개 튜플

- 빈 튜플 : 빈 괄호

- 1개 항목의 튜플 : 1개 항목 뒤에 쉼표 (괄호 안에 항목 1개가 아님)

 

問題は 0 個または 1 個の項目からなるタプルの構築です。これらの操作を行うため、構文には特別な細工がされています。

空のタプルは空の丸括弧ペアで構築できます。

一つの要素を持つタプルは、値の後ろにコンマを続ける (単一の値を丸括弧で囲むだけでは不十分です) ことで構築できます。

美しくはないけれども、効果的です。

 

>>> empty = ()
>>> singleton = 'hello',    # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

 

 

튜플 패킹

t = 12345, 54321, 'hello!'

12345, 54321, 'hello!' 는 튜플로 패킹

 

文 t = 12345, 54321, 'hello!' は タプルのパック (tuple packing) の例です。

値 12345, 54321, 'hello!' が一つのタプルにパックされます。

 

 

시퀀스 언 패킹

x, y, z = t

오른쪽에 어떤 시퀀스가 와도 됨.(ex) 리스트, 튜플)

시퀀스 언 패킹은 같은 길이 요구 - 다르면 valueError -->  ‘_’ 로 자리를 채움

다중 대입은 사실 튜플 패킹과 시퀀스 언 패킹의 조합

 

シーケンスのアンパック (sequence unpacking)

右辺には全てのシーケンス型を使うことができます。

シーケンスのアンパックでは、等号の左辺に列挙されている変数が、右辺のシーケンスの長さと同じ数だけあることが要求されます。

複数同時の代入が実はタプルのパックとシーケンスのアンパックを組み合わせたものに過ぎないことに注意してください。

 

 

 

---

5.4. 집합 集合型

 

집합 자료형

집합은 중복, 순서 없는 컬렉션

기본 용도: 멤버 검사와 중복 엔트리 제거

집합 객체는 수학적 연산 지원 (합집합, 교집합, 차집합, 대칭 차집합)

 

集合 (set)

集合とは、重複する要素をもたない、順序づけられていない要素の集まりです。

Set オブジェクトは、和 (union)、積 (intersection)、差 (difference)、対称差 (symmetric difference)といった数学的な演算もサポートしています。

 

집합 생성

{ }나 set() 사용

주의: 빈 집합 : set() (cf) {} : 빈 딕셔너리 )

 

中括弧、または set() 関数は set を生成するために使用することができます。

注: 空集合を作成するためには set() を使用しなければなりません。 ({} : 空の辞書を作成します。)

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}

>>> 'orange' in basket                 # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}

>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

 

 

집합 컴프리헨션

リスト内包 と同様に、 set 内包もサポートされています:

 

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

 

 

---

5.5. 딕셔너리 辞書型 (dictionary)

 

딕셔너리 (= 사전형 dictionary)

- 매핑 컬렉션 (‘키’와 ‘값’을 짝지어 모아두는 데이터 저장방식. ‘키’로 데이터를 검색)

- 다른 언어 "연관 메모리(associative memories)" 나 "연관 배열(associative arrays)" 의 형태

 

もう一つ、有用な型が Python に組み込まれています。それは 辞書 (dictionary) (マッピング型 )です。

辞書は他の言語にも "連想記憶 (associated memory)" や "連想配列 (associative array)" という名前で存在することがあります。

 

 

시퀀스 인덱싱 :  ‘순서(숫자)’ 

딕셔너리 인덱싱 - ‘키’ 

 

 

키 - 불변형으로 이루어 짐

- 문자열 / 숫자 / 문자열, 숫자, 튜플로만 이루어진 튜플

- 직접/간접적으로 가변 객체를 포함한 튜플 x

- 리스트 x

 

ある範囲の数でインデクス化されているシーケンスと異なり、辞書は キー (key) でインデクス化されています。

このキーは何らかの変更不能な型になります。文字列、数値は常にキーにすることができます。

 

タプルは、文字列、数値、その他のタプルのみを含む場合はキーにすることができます。直接、あるいは間接的に変更可能なオブジェクトを含むタプルはキーにできません。

 

リストをキーとして使うことはできません。

これは、リストにスライスやインデクス指定の代入を行ったり、 append()や extend() のようなメソッドを使うと、インプレースで変更することができるためです。

 

 

딕셔너리 맏들기

- 제약 조건 : 키 중복 x

- {키1:값1, 키2:값2, 키3:값3, ... }

- 빈 딕셔너리 : {}

 

辞書は キー(key): 

値(value) のペアの集合であり、キーが (辞書の中で)一意でければならない、と考えるとよいでしょう。

波括弧 (brace) のペア: {} は空の辞書を生成します。カンマで区切られた key: value のペアを波括弧ペアの間に入れると、辞書の初期値となる key: value が追加されます; 

この表現方法は出力時に辞書が書き出されるのと同じ方法です。

 

딕셔너리 연산

key:value 형태로 저장

key값으로 value 출력

del - key:value 삭제

중복 키 저장 - 값 덮어 씀

없는 키로 값 출력 - 에러

 

辞書での主な操作は、

ある値を何らかのキーを付けて記憶することと、キーを指定して値を取り出すことです。

del で key: value のペアを削除することもできます。

すでに使われているキーを使って値を記憶すると、以前そのキーに関連づけられていた値は忘れ去られてしまいます。

存在しないキーを使って値を取り出そうとするとエラーになります。

 

list(d)

    키를 삽입순서대로 리스트로 출력

sorted(d)

    키를 정렬하여 출력

keyword in 딕셔너리

    딕셔너리에 ‘keyword’라는 키가 있는지 검

 

辞書オブジェクトに対し 

list(d) を実行すると、辞書で使われている全てのキーからなるリストをキーが挿入された順番で返します

(ソートされたリストが欲しい場合は、代わりに sorted(d) を使ってください)。

ある単一のキーが辞書にあるかどうか調べるには、 in キーワードを使います。

 

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

 

dict()

key-value 쌍들의 시퀀스로 부터 직접 딕셔너리를 구성합니다.

dict() コンストラクタは、キーと値のペアのタプルを含むリストから辞書を生成します:

 

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}

 

딕셔너리 컴프리헨션 

辞書内包表現を使って、任意のキーと値のペアから辞書を作れます:

 

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

 

'키'가 '문자열'일 때, '키워드 인자'로 value를 지정할 수 있음

キーが単純な文字列の場合、キーワード引数を使って定義する方が単純な場合もあります:

 

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}

 

 

 

---

5.6. 루프 테크닉 ループのテクニック

 

딕셔너리.items()

辞書に対してループを行う際、

items() メソッドを使うと、キーとそれに対応する値を同時に取り出せます。

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

 

 

시퀀스 : enumerate()

シーケンスにわたるループを行う際、

enumerate() 関数を使うと、要素のインデックスと要素を同時に取り出すことができます。

 

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

 

 

둘 이상 시퀀스, zip()

二つまたはそれ以上のシーケンス型を同時にループするために、関数 zip() を使って各要素をひと組みにすることができます。

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

시퀀스를 거꾸로 루프 reversed()

 

シーケンスを逆方向に渡ってループするには、

まずシーケンスの範囲を順方向に指定し、次いで関数 reversed() を呼び出します。

 

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

 

 

sorted() : 정렬된 새 리스트

 

シーケンスをソートされた順序でループするには、 sorted() 関数を使います。この関数は元の配列を変更せず、ソート済みの新たな配列を返します。

 

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):    # 기준 알파벳 순
...     print(f)
...
apple
banana
orange
pear

 

루프에 있는 리스트를 변경 - 새 리스트를 만드는 것이 더 간단, 더 안전 

ときどきループ内でリストを変更したい誘惑に駆られるでしょうが、代わりに新しいリストを作ってしまうほうがより簡単で安全なことが、ままあります

>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
...     if not math.isnan(value):
...         filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]

 

 

---

5.7. 조건 더 보기 条件についてもう少し

 

 

while 과 if 문 : 조건에 비교뿐만 아니라 모든 연산자 사용가능

while や if 文で使った条件 (condition) には、値の比較だけでなく、他の演算子も使うことができます。

 

 

in, not in : 값이 있는지 check

is, is not : 두 객체가 같은 객체인지 비교

가변 객체만 해당 (ex) list)

우선순위 : 산술 >비교 

 

比較演算子 in および not in は、

ある値があるシーケンス中に存在するか (または存在しないか) どうかを調べます。

演算子 is および is not は、二つのオブジェクトが実際に同じオブジェクトであるかどうかを調べます。

この比較は、リストのような変更可能なオブジェクトにだけ意味があります。全ての比較演算子は同じ優先順位を持っており、ともに数値演算子よりも低い優先順位となります。(訳注: is は、 is None のように、シングルトンの変更不能オブジェクトとの比較に用いる場合もあります。(「変更可能なオブジェクトにだけ意味があります」の部分を削除することを Doc-SIG に提案中。))

 

 

 

비교 - 연쇄가능

a < b == c

a 가 b 보다 작고, 동시에 b 가 c 와 같은지 검사합니다.

 

比較は連結させることができます。

例えば、 a < b == c は、 a が b より小さく、かつ b と cが等しいかどうかをテストします。

 

 

논리 연산자 (and, or, not)

우선순위 : 비교 > 논리 (not > and > or)

A and not B or C = (A and (not B)) or C

 

ブール演算子 and や or で比較演算を組み合わせることができます。

そして、比較演算 (あるいは何らかのブール式) の結果の否定は not でとれます。これらの演算子は全て、比較演算子よりも低い優先順位になっています。

A and not B or C と (A and (not B)) or C が等価になるように、ブール演算子の中で、 not の優先順位が最も高く、 or が最も低くなっています。

もちろん、丸括弧を使えば望みの組み合わせを表現できます。

논리 연산자 and 와 or 는 소위 단락-회로(short-circuit) 연산자

인자들은 왼쪽에서 오른쪽으로 값이 구해지고, 결과가 결정되면 값 구하기는 중단

 

예

A, C : 참, B :거짓

A and B and C 는 C 의 값을 구하지 않음

 

 

논리값이 아닌 일반 값으로 사용될 때,

단락-회로 연산자의 반환 값은 마지막 값이 구해진 인자입니다.

결과를 변수에 대입할 수 있습니다.

 

ブール演算子 and と or は、いわゆる 短絡 (short-circuit) 演算子です。

これらの演算子の引数は左から右へと順に評価され、結果が確定した時点で評価を止めます。

例えば、 A と C は真で B が偽のとき、 A and B and C は式 C を評価しません。

 

一般に、短絡演算子の戻り値をブール値ではなくて一般的な値として用いると、値は最後に評価された引数になります。

比較や他のブール式の結果を変数に代入することもできます。

 

>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'

 

 

대입은 표현식 안에 등장할 수 없습니다. (C와 다름)

C의 문제 회피( ==를 =로 입력하는 실수)

 

Python では、C 言語と違って、式の内部で代入を行えないので注意してください。

C 言語のプログラマは不満に思うかもしれませんが、

C 言語プログラムで遭遇する、式の中で == のつもりで = とタイプしてしまうといったありふれた問題を回避します。

 

 

 

---

5.8. 시퀀스와 다른 형 비교하기 シーケンスとその他の型の比較

 

시퀀스 객체들은 같은 시퀀스 형과 비교가능

 

사전식 순서

차례대로 비교. 어느 한 시퀀스가 소진될 때까지 계속합니다.

 

만약 비교되는 두 항목 자체가 같은 형의 시퀀스면, 사전식 비교가 재귀적으로 수행

모든 항목이 같으면 같은 것으로 취급

 

포함되는 짧은 시퀀스는 작은 것입니다.

문자열의 사전식 배열은 개별 문자들의 순서를 정하는데 유니코드 코드 포인트 숫자를 사용합니다.

 

 

シーケンスオブジェクトは同じシーケンス型の他のオブジェクトと比較できます。

比較には 辞書的な (lexicographical) 順序が用いられます。

まず、最初の二つの要素を比較し、その値が等しくなければその時点で比較結果が決まります。等しければ次の二つの要素を比較し、以降シーケンスの要素が尽きるまで続けます。

比較しようとする二つの要素がいずれも同じシーケンス型であれば、そのシーケンス間での辞書比較を再帰的に行います。

二つのシーケンスの全ての要素の比較結果が等しくなれば、シーケンスは等しいとみなされます。

片方のシーケンスがもう一方の先頭部分にあたる部分シーケンスならば、短い方のシーケンスが小さいシーケンスとみなされます。

文字列に対する辞書的な順序づけには、個々の文字を並べるのに Unicode コードポイントの数を用います。

(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

 

 

서로 다른 형의 객체들을 <, > 로 비교하는 것은, 그 객체들이 적절한 비교 메서드들을 갖고 있을 때만 허락 됨

 

예를 들어, 

서로 다른 숫자 형들은 그들의 숫자 값에 따라 비교 그래서 0은 0.0과 같고, 등등.

그렇지 않으면, TypeError 를 일으킵니다.

 

違う型のオブジェクト同士を < や > で比較することも、それらのオブジェクトが適切な比較メソッドを提供しているのであれば許可されます。例えば、異なる数値型同士の比較では、その数値によって比較が行われます。例えば、 0 と 0.0 は等価です。一方、適切な比較順序がない場合は、インタープリターは TypeError 例外を発生させます。