一简介#
Python は著名な「亀おじさん」Guido van Rossumによって 1989 年に開発されました。
Python はクロスプラットフォームであり、Windows、Mac、さまざまな Linux/Unix システムで実行できます。Windows で書いた Python プログラムは、Linux でも実行可能です。
利点
1 Python は非常に充実した基礎コードライブラリを提供しており、ネットワーク、ファイル、GUI、データベース、テキストなどの多くの内容をカバーしており、象徴的に「内蔵バッテリー（batteries included）」と呼ばれています。Python で開発することで、多くの機能をゼロから書く必要がなく、既存のものを直接使用できます。
2 内蔵ライブラリに加えて、Python には大量のサードパーティライブラリもあり、他の人が開発したものを直接使用できます。
欠点
1 実行速度が遅く、C プログラムと比較すると非常に遅いです。Python はインタプリタ型言語であり、コードを実行する際に一行ずつ CPU が理解できる機械語に翻訳されるため、この翻訳プロセスは非常に時間がかかり、遅くなります。一方、C プログラムは実行前に直接 CPU が実行できる機械語にコンパイルされるため、非常に速いです。
2 コードを暗号化できません。Python プログラムを公開する場合、実際にはソースコードを公開することになります。これは C 言語とは異なり、C 言語ではソースコードを公開する必要はなく、コンパイルされた機械語（Windows で一般的な xxx.exe ファイル）を公開するだけで済みます。機械語から C コードを逆算することは不可能です。そのため、コンパイル型言語にはこの問題はありませんが、インタプリタ型言語ではソースコードを公開する必要があります。
python インタプリタ
Python コードを記述すると、.py 拡張子の付いたテキストファイルが得られます。コードを実行するには、Python インタプリタが.py ファイルを実行する必要があります。
python インタプリタ：
CPython：Python 公式サイトから Python 3.x をダウンロードしてインストールすると、公式バージョンのインタプリタである CPython が得られます。このインタプリタは C 言語で開発されているため、CPython と呼ばれます。コマンドラインで python を実行すると、CPython インタプリタが起動します。
IPython：CPython の上に構築されたインタラクティブインタプリタであり、IPython はインタラクティブな方法が強化されているだけで、Python コードを実行する機能は CPython と全く同じです。
PyPy：別の Python インタプリタで、実行速度を目指しています。PyPy は JIT 技術を採用し、Python コードを動的にコンパイル（注意：解釈ではありません）するため、Python コードの実行速度を大幅に向上させることができます。ほとんどの Python コードは PyPy で実行できますが、PyPy と CPython にはいくつかの違いがあるため、同じ Python コードが 2 つのインタプリタで実行されると異なる結果が得られる場合があります。コードを PyPy で実行する場合は、PyPy と CPython の違いを理解する必要があります。
Jython：Java プラットフォーム上で動作する Python インタプリタで、Python コードを直接 Java バイトコードにコンパイルして実行できます。
IronPython：IronPython は Jython に似ていますが、IronPython は Microsoft .Net プラットフォーム上で動作する Python インタプリタで、Python コードを直接.Net のバイトコードにコンパイルできます。
Python のインタプリタは多くありますが、最も広く使用されているのはCPythonです。Java や.Net プラットフォームと相互作用する場合、最良の方法は Jython や IronPython を使用するのではなく、ネットワーク呼び出しを介して相互作用し、各プログラム間の独立性を確保することです。
コマンドラインモードと Python インタラクティブモード
コマンドラインモードでは、python を実行して Python インタラクティブ環境に入ることも、python hello.py を実行して.py ファイルを実行することもできます。
.py ファイルを実行するにはコマンドラインモードで実行する必要があります。コマンドを入力して python hello.py を実行します。
Python インタラクティブ環境は、各行の Python コードの結果を自動的に表示しますが、直接 Python コードを実行しても表示されません。
Python インタラクティブモードでは、1 行を入力して実行しますが、コマンドラインモードで.py ファイルを直接実行すると、そのファイル内のすべてのコードが一度に実行されます。したがって、Python インタラクティブモードは主に Python コードのデバッグ用であり、初心者が学ぶのに便利です。これは正式に Python コードを実行する環境ではありません！
テキストエディタ
Visual Studio Code：Microsoft 製、クロスプラットフォーム。
注意：Word や Windows に付属のメモ帳を使用しないでください。Word で保存されるのはプレーンテキストファイルではなく、メモ帳はファイルの先頭にいくつかの特殊文字（UTF-8 BOM）を追加するため、結果的にプログラムの実行に不可解なエラーが発生します。
ファイル名は英字、数字、アンダースコアの組み合わせのみ使用できます。
py ファイルを直接実行する
.py ファイルを.exe ファイルのように直接実行できますか？Windows ではできませんが、Mac や Linux では可能です。その方法は、.py ファイルの最初の行に特殊なコメントを追加することです：
#!/usr/bin/env python3
print('hello, world')
次に、コマンドで hello.py に実行権限を与えます：
$ chmod a+x hello.py
これで hello.py を直接実行できるようになります。
Python でプログラムを開発する際は、テキストエディタでコードを書きながら、インタラクティブなコマンドウィンドウを開いて、コードの一部をコマンドラインに貼り付けて検証することで、効率的に作業できます！
入力と出力
出力：
print () の括弧内に文字列を追加することで、画面に指定した文字を出力できます。
print () 関数は複数の文字列を受け入れることもでき、カンマ「,」で区切ることで連結して出力できます：
print('The quick brown fox', 'jumps over', 'the lazy dog')
print () は各文字列を順に印刷し、カンマ「,」に出会うと空白を出力します。したがって、出力される文字列はこのように結合されます：
入力：
input () を使用すると、ユーザーが文字列を入力し、変数に保存できます。たとえば、ユーザーの名前を入力する場合：
>>>name = input()
Michael
name = input () を入力して Enter を押すと、Python インタラクティブコマンドラインがあなたの入力を待っています。このとき、任意の文字を入力し、Enter を押すことで入力が完了します。
入力が完了すると、何の提示もなく、Python インタラクティブコマンドラインは再び >>> の状態に戻ります。では、先ほど入力した内容はどこに行ったのでしょうか？答えは、name 変数に保存されています。変数の内容を確認するには、直接 name を入力します：
>>> name
'Michael'
コンピュータプログラムにおいて、変数は整数や浮動小数点数だけでなく、文字列としても使用できます。したがって、name は文字列としての変数です。
name 変数の内容を印刷するには、直接 name を入力して Enter を押すだけでなく、print () 関数を使用することもできます：
>>> print(name)
Michael
input () を使用すると、ユーザーに表示する文字列を提示できます：
name = input('please enter your name: ')
print('hello,', name)
入力は Input、出力は Output であるため、入力と出力を総称して Input/Output、または略して IO と呼びます。
二 python 基礎#
どのプログラミング言語にも独自の文法があり、コンパイラやインタプリタは文法に従ったプログラムコードを CPU が実行できる機械語に変換し、実行します。
Python の文法は比較的簡単で、** インデント** 方式を採用しています。
# 整数の絶対値を印刷する：
a = 100
if a >= 0:
print(a)
else:
print(-a)
#で始まる文はコメントであり、コメントは人間が読むためのもので、任意の内容を含むことができ、インタプリタはコメントを無視します。他の各行は文であり、文がコロン：で終わる場合、インデントされた文はコードブロックと見なされます。
インデントには利点と欠点があります。利点は、フォーマットされたコードを書くことを強制することですが、インデントが何スペースか Tab かは規定されていません。慣習に従って、常に4 つのスペースのインデントを使用するべきです。
インデントの欠点は、「コピー＆ペースト」機能が無効になることであり、これは不便な点です。コードをリファクタリングする際、ペーストしたコードのインデントが正しいかどうかを再確認する必要があります。また、IDE は Java コードのように Python コードをフォーマットするのが難しいです。
注意：Python プログラムは大文字と小文字を区別します。大文字と小文字を間違えると、プログラムはエラーを報告します。
データ型と変数#
コンピュータは数値だけでなく、テキスト、グラフィック、音声、動画、ウェブページなどさまざまなデータを処理できます。異なるデータには異なるデータ型を定義する必要があります。Python で直接処理できるデータ型には以下のものがあります：
2.1 整数
Python は任意のサイズの整数を処理でき、もちろん負の整数も含まれます。プログラム内での表現方法は数学的な書き方と全く同じです。たとえば：1、100、-8080、0 など。
コンピュータは二進法を使用しているため、時には 16 進数で整数を表現する方が便利です。16 進数は 0x プレフィックスと 0-9、a-f を使用します。たとえば：0xff00、0xa5b4c3d2 など。
非常に大きな数、たとえば 10000000000 は、0 の数を数えるのが難しいです。Python は数字の間に_で区切ることを許可しているため、10_000_000_000 と 10000000000 は全く同じです。16 進数も 0xa1b2_c3d4 のように書くことができます。
2.2 浮動小数点数
浮動小数点数は小数のことです。浮動小数点数と呼ばれる理由は、科学的記数法で表現する際に、小数点の位置が可変であるためです。たとえば、1.23x10^9 と 12.3x10^8 は完全に等しいです。浮動小数点数は数学的な書き方で表現できます。たとえば、1.23、3.14、-9.01 など。しかし、非常に大きいまたは非常に小さい浮動小数点数は、科学的記数法で表現する必要があります。10 を e で置き換え、1.23x10^9 は 1.23e9、または 12.3e8、0.000012 は 1.2e-5 のように書くことができます。
整数と浮動小数点数は、コンピュータ内部での保存方法が異なります。整数の演算は常に正確です（除算も正確ですか？はい！）、一方、浮動小数点数の演算には四捨五入の誤差が生じる可能性があります。
2.3 文字列
文字列はシングルクォート' またはダブルクォート"で囲まれた任意のテキストです。たとえば、'abc'、"xyz"など。注意してください、'' または"" 自体は表現方法であり、文字列の一部ではありません。したがって、文字列 'abc' には a、b、c の 3 つの文字だけがあります。' 自体も文字である場合、""で囲むことができます。たとえば、"I'm OK" には I、'、m、空白、O、K の 6 つの文字が含まれています。
文字列内部に ' と " の両方が含まれている場合はどうすればよいでしょうか？エスケープ文字\ を使用して識別できます。たとえば：
'I\'m \"OK\"!'
表現される文字列の内容は：
I'm "OK"!
エスケープ文字 \ は多くの文字をエスケープできます。たとえば、\n は改行を、\t はタブを表します。文字 \ 自体もエスケープする必要があるため、\\ は \ を表します。
文字列の中に多くの文字がエスケープされる必要がある場合、多くの \ を追加する必要があります。簡略化のために、Python は r'' を使用して '' 内部の文字列がデフォルトでエスケープされないことを許可しています。
>>> print('\\\t\\')
\ \
>>> print(r'\\\t\\')
\\\t\\
文字列内部に多くの改行がある場合、\n を 1 行で書くのは読みづらいため、Python は '''...''' の形式を使用して複数行の内容を表現することを許可しています。
>>> print('''line1
... line2
... line3''')
line1
line2
line3
上記はインタラクティブコマンドライン内で入力されたもので、複数行の内容を入力する際、プロンプトが >>> から... に変わり、前の行の続きとして入力できることを示しています。注意：... はプロンプトであり、コードの一部ではありません。終了記号 ``` と括弧) を入力した後、その文を実行して結果を印刷します。
プログラムとして書き、.py ファイルとして保存すると、次のようになります：
print('''line1
line2
line3''')
複数行の文字列 '''...''' の前に r を追加することもできます。
print(r'''hello,\n
world''')
hello,\n
world
2.4 ブール値
ブール値はブール代数の表現と完全に一致し、ブール値はTrueまたはFalseの 2 つの値しか持たず、True であるか False であるかのいずれかです。Python では、True、False を直接使用してブール値を表現できます（大文字と小文字に注意してください）。また、ブール演算を通じて計算することもできます：
>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False
ブール値はand、or、not演算を使用できます。
and 演算は論理積であり、すべてが True である場合にのみ、and 演算の結果は True になります。
or 演算は論理和であり、そのうちの 1 つが True であれば、or 演算の結果は True になります。
not 演算は論理否定であり、これは単項演算子で、True を False に、False を True に変えます。
not 演算は論理否定であり、これは単項演算子で、True を False に、False を True に変えます。
2.5 空値
空値は Python における特別な値で、Noneで表されます。None は 0 と理解されるべきではありません。なぜなら、0 には意味があるからです。None は特別な空の値です。
さらに、Python はリスト、辞書などのさまざまなデータ型を提供し、カスタムデータ型を作成することも許可しています。
変数
変数はプログラム内で変数名を使用して表現され、変数名は大文字と小文字の英字、数字、_の組み合わせでなければならず、数字で始めることはできません。
Python では、等号 = は代入文であり、任意のデータ型を変数に代入できます。同じ変数に何度も代入でき、異なる型の変数でも構いません。
このように変数自体の型が固定されていない言語は動的言語と呼ばれ、これに対して静的言語があります。静的言語では、変数を定義する際に変数の型を指定する必要があり、代入時に型が一致しないとエラーが発生します。たとえば、Java は静的言語であり、代入文は次のようになります（// はコメントを示します）：
int a = 123; // aは整数型変数
a = "ABC"; // エラー：文字列を整数型変数に代入できません
変数がコンピュータのメモリ内でどのように表現されるかを理解することも非常に重要です。
a = 'ABC'
Python インタプリタは 2 つのことを行います：
メモリ内に 'ABC' という文字列を作成します；
メモリ内に a という名前の変数を作成し、それを 'ABC' に指し示します。
a = 'ABC'
b = a
a = 'XYZ'
print(b)
a = 'ABC' を実行すると、インタプリタは文字列 'ABC' と変数 a を作成し、a を 'ABC' に指し示します：
b = a を実行すると、インタプリタは変数 b を作成し、b を a が指し示す文字列 'ABC' に指し示します：
a = 'XYZ' を実行すると、インタプリタは文字列 'XYZ' を作成し、a の指し示す先を 'XYZ' に変更しますが、b は変更されません：
したがって、最後に変数 b を印刷すると、その結果は自然に 'ABC' になります。
定数
定数とは変更できない変数のことです。たとえば、よく知られている数学定数 π は定数です。Python では、通常、すべての大文字の変数名を使用して定数を表します：
PI = 3.14159265359
しかし、実際には PI は依然として変数であり、Python には PI が変更されないことを保証するメカニズムはありません。したがって、すべての大文字の変数名を使用して定数を表すことは単なる慣習的な使い方であり、もしあなたが PI の値を変更したい場合、誰もあなたを止めることはできません。
整数の除算がなぜ正確であるかを説明します。Python には 2 種類の除算があります。1 つは / です：
>>> 10 / 3
3.3333333333333335
/ による除算の計算結果は浮動小数点数であり、たとえ 2 つの整数がちょうど割り切れる場合でも、結果は浮動小数点数になります：
>>> 9 / 3
3.0
もう 1 つの除算は // であり、これは床除算と呼ばれ、2 つの整数の除算は依然として整数になります：
>>> 10 // 3
3
あなたは間違っていません。整数の床除算 // は常に整数であり、たとえ割り切れなくてもそうです。正確な除算を行うには、/ を使用すればよいです。
// による除算は結果の整数部分のみを取得するため、Python は余りの演算 % も提供しており、2 つの整数を除算した余りを取得できます：
>>> 10 % 3
1
整数が // による除算を行う場合も余りを取る場合も、結果は常に整数であるため、整数演算の結果は常に正確です。
Python はさまざまなデータ型をサポートしており、コンピュータ内部では任意のデータを「オブジェクト」と見なすことができ、変数はプログラム内でこれらのデータオブジェクトを指し示すために使用されます。変数に代入することは、データと変数を関連付けることを意味します。
変数に代入する x = y は、変数 x が実際のオブジェクトを指し示すことを意味します。そのオブジェクトは変数 y が指し示すものです。その後、変数 y の代入は変数 x の指し示す先に影響を与えません。
注意：Python の整数にはサイズ制限がなく、他の言語の整数はそのストレージ長に応じてサイズ制限があります。たとえば、Java の 32 ビット整数の範囲は - 2147483648 から 2147483647 までです。
Python の浮動小数点数にもサイズ制限はありませんが、一定の範囲を超えると直接 inf（無限大）として表されます。
list と tuple#
list
Python に内蔵されているデータ型のリストです。list は順序付きのコレクションであり、いつでもその要素を追加したり削除したりできます。
たとえば、クラスのすべての生徒の名前を列挙する場合、list を使用して表現できます：
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']
変数 classmates は list です。len () 関数を使用して list の要素数を取得できます：
>>> len(classmates)
3
インデックスを使用して list 内の各位置の要素にアクセスします。インデックスは0から始まることを忘れないでください。
>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
インデックスが範囲を超えると、Python はIndexErrorエラーを報告します。したがって、インデックスが越えないように注意し、最後の要素のインデックスはlen(classmates) - 1であることを覚えておいてください。
最後の要素を取得するには、インデックス位置を計算する代わりに - 1 を使用して、最後の要素を直接取得できます：
>>> classmates[-1]
'Tracy'
list は可変の順序付きリストであるため、list の末尾に要素を追加できます：
list.append('')
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
list.insert(num,'')
特定の位置に要素を挿入することもできます。たとえば、インデックス番号 1 の位置に挿入します：
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
list.pop()
list の末尾の要素を削除するには、pop () メソッドを使用します：
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
list.pop(i)
特定の位置の要素を削除するには、pop (i) メソッドを使用します。ここで i はインデックス位置です：
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']
特定の要素を別の要素に置き換えるには、対応するインデックス位置に直接代入できます：
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']
list 内の要素のデータ型は異なることもできます。たとえば：
>>> L = ['Apple', 123, True]
list の要素は別の list であることもできます。たとえば：
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4
s には 4 つの要素しかないことに注意してください。その中の s [2] は別の list です。分解して書くと、より理解しやすくなります：
>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']
'php' を取得するには、p [1] または s [2][1] と書くことができます。したがって、s は二次元配列と見なすことができ、同様に三次元、四次元…… の配列もありますが、あまり使用されません。
list に要素が 1 つもない場合、それは空の list であり、その長さは 0 です：
>>> L = []
>>> len(L)
0
tuple
もう 1 つの順序付きリストはタプルと呼ばれます。tuple は list に非常に似ていますが、tuple は初期化後に変更できません。たとえば、同じようにクラスメートの名前を列挙する場合：
>>> classmates = ('Michael', 'Bob', 'Tracy')
現在、classmates という tuple は変更できません。append () や insert () のようなメソッドはありません。他の要素を取得する方法は list と同じで、classmates [0]、classmates [-1] を正常に使用できますが、別の要素に代入することはできません。
変更不可能な tuple にはどのような意味がありますか？tuple は変更できないため、コードはより安全です。可能であれば、tuple を list の代わりに使用することが推奨されます。
tuple の罠：tuple を定義する際、定義時に tuple の要素を確定させる必要があります。たとえば：
>>> t = (1, 2)
>>> t
(1, 2)
空の tuple を定義するには、() と書くことができます：
>>> t = ()
>>> t
()
しかし、要素が 1 つだけの tuple を定義する場合、次のように定義すると：
>>> t = (1)
>>> t
1
定義されたのは tuple ではなく、1 という数です！これは、括弧 () が tuple を表すだけでなく、数学的な式の小括弧を表すこともできるため、曖昧さが生じます。したがって、Python はこの場合、小括弧として計算し、結果は自然に 1 になります。
したがって、要素が 1 つだけの tuple を定義する際は、カンマを追加して曖昧さを解消する必要があります：
>>> t = (1,)
>>> t
(1,)
Python は要素が 1 つだけの tuple を表示する際にもカンマを追加し、数学的な計算の意味の括弧と誤解されないようにします。
最後に「可変の」tuple を見てみましょう：
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
この tuple は定義時に 3 つの要素を持ち、それぞれ 'a'、'b'、および list です。tuple は一度定義された後は変更できないと言われていますが、後で変更できるのはどういうことでしょうか？
まず、定義時に tuple が含む 3 つの要素を見てみましょう：
list の要素 'A' と 'B' を 'X' と 'Y' に変更すると、tuple は次のようになります：
表面的には、tuple の要素が確かに変わったように見えますが、実際には変わったのは tuple の要素ではなく、list の要素です。tuple が最初に指し示していた list は他の list に変更されていないため、tuple の「不変」とは、tuple の各要素が指し示す先が永遠に変わらないことを意味します。つまり、'a' を指し示す場合、'b' を指し示すことはできず、list を指し示す場合、他のオブジェクトを指し示すことはできませんが、指し示している list 自体は可変です！
「指し示す先が変わらない」ことを理解した後、内容も変わらない tuple を作成するには、tuple の各要素自体も変更できないことを保証する必要があります。
list と tuple は Python に内蔵された順序付きコレクションであり、一方は可変であり、もう一方は不変です。
条件判断#
Python のインデントルールによれば、if 文の判断が True であれば、インデントされた 2 行の print 文が実行されます。if の判断が False であれば、else が実行されます。
コロンを忘れないでください：
age = 3
if age >= 18:
print('your age is', age)
print('adult')
else:
print('your age is', age)
print('teenager')
elif は else if の略であり、複数の elif を持つことができます。
if 文の実行の特徴：上から下に判断され、ある判断が True であれば、その判断に対応する文が実行された後、残りの elif と else は無視されます。
if <条件判断1>:
<実行1>
elif <条件判断2>:
<実行2>
elif <条件判断3>:
<実行3>
else:
<実行4>
if 判断条件は簡略化することもできます。たとえば、次のように書くことができます：
if x:
print('True')
x が非ゼロの数値、非空の文字列、非空の list などであれば、True と判断され、それ以外は False と判断されます。
再議 input
TypeError
birth = input('birth: ')
if birth < 2000:
print('00前')
else:
print('00後')
1982 を入力すると、結果はエラーになります：
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() > int()
これは、input () が返すデータ型が str であり、str は整数と直接比較できないためです。まず、str を整数に変換する必要があります。Python はこの作業を行うためにint () 関数を提供しています。
int () 関数は、文字列が有効な数字でない場合にエラーを報告し、プログラムは終了します。
s = input('birth: ')
birth = int(s)
if birth < 2000:
print('00前')
else:
print('00後')
再度実行すると、正しい結果が得られます。しかし、abc を入力するとどうなるでしょうか？再びエラーが発生します：
ValueError
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'abc'
ループ#
for...in ループ
Python のループには 2 種類あり、1 つは for...in ループで、list や tuple の各要素を順に反復処理します。
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)
このコードを実行すると、names の各要素が順に印刷されます：
Michael
Bob
Tracy
したがって、for x in ... ループは各要素を変数 x に代入し、インデントされたブロックの文を実行します。
range () 関数は整数のシーケンスを生成し、list () 関数を通じて list に変換できます。たとえば、range (5) が生成するシーケンスは 0 から始まり 5 未満の整数です：
>>> list(range(5))
[0, 1, 2, 3, 4]
while ループ
もう 1 つのループは while ループであり、条件が満たされている限り、ループを繰り返し、条件が満たされなくなるとループを終了します。
break
ループ内で break 文を使用すると、ループを早期に終了できます。
n = 1
while n <= 100:
if n > 10: # n = 11のとき、条件が満たされ、break文が実行されます
break # break文は現在のループを終了します
print(n)
n = n + 1
print('END')
上記のコードを実行すると、1〜10 が印刷された後、すぐに END が印刷され、プログラムが終了します。
continue
ループの過程で、continue 文を使用して、現在のループをスキップし、次のループを直接開始することもできます。
n = 0
while n < 10:
n = n + 1
if n % 2 == 0: # nが偶数の場合、continue文が実行されます
continue # continue文は次のループを直接続行し、後続のprint()文は実行されません
print(n)
break 文はループを直接終了し、continue 文は現在のループを終了し、次のループを直接開始します。これら 2 つの文は通常 if 文と組み合わせて使用されます。
特に注意が必要なのは、break と continue 文を乱用しないことです。
「無限ループ」とは、永遠にループし続けることを指します。この場合、Ctrl+C を使用してプログラムを終了するか、Python プロセスを強制終了できます。
dict と set#
dict
Python は辞書：dict を内蔵しており、dict は dictionary の略称で、他の言語では map とも呼ばれ、キー - 値（key-value）ストレージを使用し、非常に高速な検索速度を持っています。
dict を使用すると、「名前」と「成績」の対照表を作成し、名前に基づいて成績を直接検索できます。この表がどれほど大きくても、検索速度は遅くなりません。
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
なぜ dict の検索速度がこれほど速いのでしょうか？dict の実装原理は辞書を調べるのと同じです。辞書に 1 万の漢字が含まれていると仮定し、特定の字を調べる場合、1 つの方法は辞書を最初のページからめくり、目的の字が見つかるまで進むことです。この方法は list 内の要素を検索する方法であり、list が大きくなるほど検索が遅くなります。
もう 1 つの方法は、辞書の索引表（たとえば部首表）でその字に対応するページ番号を調べ、直接そのページをめくって目的の字を見つけることです。どの字を探しても、この方法の検索速度は非常に速く、辞書のサイズが増加しても遅くなりません。
dict はこの第二の実装方法を採用しており、特定の名前（たとえば 'Michael'）を与えると、dict は内部で Michael に対応する成績の「ページ番号」、つまり 95 という数字が保存されているメモリアドレスを直接計算し、すぐに取得します。したがって、速度は非常に速いです。
推測できるように、この key-value ストレージ方式では、データを格納する際に、key に基づいて value の格納位置を計算する必要があります。そうすれば、取得する際に key に基づいて直接 value を取得できます。
dict にデータを格納する方法は、初期化時に指定する以外にも、key を使用して格納することができます：
>>> d['Adam'] = 67
>>> d['Adam']
67
1 つの key は 1 つの value にしか対応できないため、同じ key に対して value を何度も格納すると、後の値が前の値を上書きします：
>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88
key が存在しない場合、dict はエラーを報告します：KeyError
>>> d['Thomas']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Thomas'
key が存在しないエラーを回避するには、2 つの方法があります。
1 つはinを使用して key が存在するかどうかを確認することです：
>>> 'Thomas' in d
False
もう 1 つは、dict が提供するget () メソッドを使用することで、key が存在しない場合はNoneを返すか、指定した value を返すことができます：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
注意：None を返す場合、Python のインタラクティブ環境では結果が表示されません。
key を削除するには、pop (key) メソッドを使用します。対応する value も dict から削除されます：
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
dict 内部に格納されている順序は、key を格納した順序とは関係がないことに注意してください。
list と比較して、dict には以下の特徴があります：
1 検索と挿入の速度が非常に速く、key が増えても遅くなりません；
2 大量のメモリを占有し、メモリの浪費が多いです。
一方、list は次のようになります：
1 検索と挿入の時間は要素の増加に伴って増加します；
2 占有するスペースは小さく、メモリの浪費は少ないです。
したがって、dict は時間を交換するためのスペースの方法です。
dict は高速検索が必要な多くの場所で使用され、Python コードのほぼすべての場所に存在します。dict を正しく使用することは非常に重要であり、最初に覚えておくべきことはdict の key は不変オブジェクトでなければならないということです。
これは、dict が key に基づいて value の格納位置を計算するためです。同じ key に対して異なる結果が得られると、dict 内部が完全に混乱してしまいます。この key に基づく位置計算アルゴリズムはハッシュアルゴリズム（Hash）と呼ばれます。
ハッシュの正確性を保証するためには、key として使用されるオブジェクトは変更できない必要があります。Python では、文字列や整数などは不変であるため、安心して key として使用できます。一方、list は可変であるため、key として使用できません：
>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
set
set は dict に似ており、key の集合ですが、value は格納されません。key は重複できないため、set には重複する key がありません。
set を作成するには、入力集合として list を提供する必要があります：
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
注意：渡された引数 [1, 2, 3] は list であり、表示される {1, 2, 3} は set 内部に 1、2、3 の 3 つの要素があることを示すだけで、表示される順序はset が順序付きであることを示すものではありません。
重複する要素は set 内で自動的にフィルタリングされます：
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}
add (key) メソッドを使用して set に要素を追加できます。重複して追加することはできますが、効果はありません：
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
remove (key) メソッドを使用して要素を削除できます：
>>> s.remove(4)
>>> s
{1, 2, 3}
set は数学的な意味での無秩序かつ重複しない要素の集合と見なすことができるため、2 つの set は数学的な意味での交差、和などの操作を行うことができます：
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
set と dict の唯一の違いは、対応する value を格納しないことですが、set の原理は dict と同じであるため、同様に可変オブジェクトを格納できません。なぜなら、2 つの可変オブジェクトが等しいかどうかを判断できず、set 内部に「重複する要素がない」ことを保証できないからです。
再議不変オブジェクト
可変オブジェクト、たとえば list に対して操作を行うと、list 内部の内容は変化します。たとえば：
>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']
一方、不変オブジェクト、たとえば str に対して操作を行うとどうなるでしょうか：
>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'
文字列には replace () メソッドがあり、確かに 'Abc' を生成しますが、変数 a は最後まで 'abc' のままです。これはどのように理解すればよいでしょうか？
次のようにコードを変更してみましょう：
>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'
常に覚えておくべきことは、a は変数であり、'abc' は文字列オブジェクトです！時々、私たちは「オブジェクト a の内容は 'abc' である」と言いますが、実際には、a 自体は変数であり、a が指し示すオブジェクトの内容が 'abc' であることを指します：
a-------->'abc'
a.replace ('a', 'A') を呼び出すと、実際には replace メソッドが文字列オブジェクト 'abc' に作用します。このメソッドは replace という名前ですが、文字列 'abc' の内容を変更することはありません。逆に、replace メソッドは新しい文字列 'Abc' を作成し、返します。もし新しい文字列を指し示す変数 b を使用すれば、理解しやすくなります。変数 a は元の文字列 'abc' を指し示し続けますが、変数 b は新しい文字列 'Abc' を指し示すことになります：
a-------->'abc'
b-------->'Abc'
したがって、不変オブジェクトに対しては、そのオブジェクト自身の任意のメソッドを呼び出しても、そのオブジェクト自身の内容は変更されません。逆に、これらのメソッドは新しいオブジェクトを作成して返します。これにより、不変オブジェクト自体が常に不変であることが保証されます。
key-value ストレージ構造を使用する dict は Python で非常に便利であり、不変オブジェクトを key として選択することが重要です。最も一般的な key は文字列です。