Python3-quick-guide

Python 3の新機能

futureモジュール

Python 3.xでは、Python 2の組み込みfutureモジュールを介してインポートできる、Python 2に互換性のないキーワードと機能が導入されました。 コードのPython 3.xサポートを計画している場合は、futureインポートを使用することをお勧めします。

たとえば、Python 2でPython 3.xの整数除算動作が必要な場合は、次のimportステートメントを追加します。

from __future__ import division

印刷機能

Python 3で最も注目され、最も広く知られている変更は、 print 関数の使用方法です。 印刷機能での括弧（）の使用は必須になりました。 Python 2ではオプションでした。

print "Hello World" #is acceptable in Python 2
print ("Hello World") # in Python 3, print must be followed by ()

print（）関数は、デフォルトで新しい行を最後に挿入します。 Python 2では、末尾に「、」を付けることで抑制できます。 Python 3では、「end = 」は改行の代わりにスペースを追加します。

print x,           # Trailing comma suppresses newline in Python 2
print(x, end=" ")  # Appends a space instead of a newline in Python 3

キーボードからの入力の読み取り

Python 2には、* input（）と raw_input（）*の2つのバージョンの入力関数があります。 input（）関数は、引用符 または ""に含まれている場合、受信したデータを文字列として扱います。そうでない場合、データは数値として扱われます

Python 3では、raw_input（）関数は非推奨です。 さらに、受信したデータは常に文字列として扱われます。

In Python 2

>>> x = input('something:')
something:10 #entered data is treated as number
>>> x
10

>>> x = input('something:')
something:'10' #entered data is treated as string
>>> x
'10'

>>> x = raw_input("something:")
something:10 #entered data is treated as string even without ''
>>> x
'10'

>>> x = raw_input("something:")
something:'10' #entered data treated as string including ''
>>> x
"'10'"

In Python 3

>>> x = input("something:")
something:10
>>> x
'10'

>>> x = input("something:")
something:'10' #entered data treated as string with or without ''
>>> x
"'10'"

>>> x = raw_input("something:") # will result NameError
Traceback (most recent call last):
   File "<pyshell#3>", line 1, in
  <module>
   x = raw_input("something:")
NameError: name 'raw_input' is not defined

整数除算

Python 2では、2つの整数の除算の結果は最も近い整数に丸められます。 その結果、3/2は1を表示します。 浮動小数点除算を取得するには、分子または分母を明示的にfloatとして使用する必要があります。 したがって、3.0/2または3/2.0または3.0/2.0は1.5になります

Python 3は、デフォルトで3/2を1.5と評価します。これは、新しいプログラマにとってより直感的です。

Unicode表現

Python 2では、Unicodeとして保存する場合、文字列をuでマークする必要があります。

Python 3はデフォルトで文字列をUnicodeとして保存します。 Unicode（utf-8）文字列、および2バイトクラス：バイト配列とバイト配列があります。

xrange（）関数が削除されました

Python 2では、range（）はリストを返し、xrange（）は必要なときに範囲内のアイテムのみを生成するオブジェクトを返し、メモリを節約します。

Python 3では、range（）関数が削除され、xrange（）はrange（）に名前が変更されました。 さらに、range（）オブジェクトはPython 3.2以降のスライスをサポートします。

例外を発生させる

Python 2は、「古い」構文と「新しい」構文の両方の表記を受け入れます。例外引数を括弧で囲まないと、Python 3はSyntaxErrorを発生させます。

raise IOError, "file error" #This is accepted in Python 2
raise IOError("file error") #This is also accepted in Python 2
raise IOError, "file error" #syntax error is raised in Python 3
raise IOError("file error") #this is the recommended syntax in Python 3

例外の引数

Python 3では、例外の引数は「as」キーワードで宣言する必要があります。

except Myerror, err: # In Python2
except Myerror as err: #In Python 3

next（）関数と.next（）メソッド

Python 2では、ジェネレーターオブジェクトのメソッドとしてnext（）が許可されています。 Python 2では、ジェネレーターオブジェクトを反復処理するnext（）関数も使用できます。 ただし、Python 3では、ジェネレーターメソッドとしてnext（0は廃止され、 AttributeError が発生します。

gen = (letter for letter in 'Hello World') # creates generator object
next(my_generator) #allowed in Python 2 and Python 3
my_generator.next() #allowed in Python 2. raises AttributeError in Python 3

2to3ユーティリティ

Python 3インタープリターとともに、2to3.pyスクリプトは通常tools/scriptsフォルダーにインストールされます。 Python 2.xソースコードを読み取り、一連のフィクサーを適用して、有効なPython 3.xコードに変換します。

Here is a sample Python 2 code (area.py):

def area(x,y = 3.14):
   a = y*x*x
   print a
   return a

a = area(10)
print "area",a

To convert into Python 3 version:

$2to3 -w area.py

Converted code :

def area(x,y = 3.14): # formal parameters
   a = y*x*x
   print (a)
   return a

a = area(10)
print("area",a)

Python 3-概要

Pythonは、高レベルで、解釈された、インタラクティブでオブジェクト指向のスクリプト言語です。 Pythonは非常に読みやすいように設計されています。 英語のキーワードを頻繁に使用しますが、他の言語では句読点を使用します。 他の言語よりも構文構造が少ない。

• * Pythonは解釈されます*-Pythonは実行時にインタプリタによって処理されます。 プログラムを実行する前にコンパイルする必要はありません。 これは、PERLおよびPHPに似ています。
• * Pythonは対話式です*-実際にPythonプロンプトに座って、インタープリターと直接対話してプログラムを作成できます。
• * Pythonはオブジェクト指向*-Pythonはオブジェクト指向のスタイルまたはオブジェクト内のコードをカプセル化するプログラミング手法をサポートしています。
• * Pythonは初心者向け言語*-Pythonは初心者レベルのプログラマーにとって素晴らしい言語であり、単純なテキスト処理からWWWブラウザ、ゲームまで、幅広いアプリケーションの開発をサポートします。

Pythonの歴史

Pythonは、オランダの数学およびコンピューター科学研究所で80年代後半から90年代初頭にGuido van Rossumによって開発されました。

• Pythonは、ABC、Modula-3、C、C ++、Algol-68、SmallTalk、Unixシェル、その他のスクリプト言語など、他の多くの言語から派生しています。
• Pythonは著作権で保護されています。 Perlと同様に、PythonソースコードはGNU General Public License（GPL）の下で利用可能になりました。
• Pythonは現在、研究所のコア開発チームによって管理されていますが、Guido van Rossumはその進行を指揮する上で依然として重要な役割を果たしています。
• Python 1.0は1994年11月にリリースされました。 2000年に、Python 2.0がリリースされました。 Python 2.7.11は、Python 2の最新版です。
• 一方、Python 3.0は2008年にリリースされました。 Python 3はPython 2と下位互換性がありません。 Python 3では、重複するプログラミング構造とモジュールを削除することに重点が置かれていたため、「それを行うには明らかな方法が1つ（できれば1つだけ）あるべきです」。 Python 3.5.1は、Python 3の最新バージョンです。

Python機能

Pythonの機能が含まれます-

• 学習しやすい-Pythonにはキーワードがほとんどなく、構造が単純で、明確に定義された構文があります。 これにより、学生はすばやく言語を習得できます。
• 読みやすい-Pythonコードがより明確に定義され、目に見えるようになりました。
• 保守が容易-Pythonのソースコードは保守が非常に簡単です。
• 幅広い標準ライブラリ-Pythonのライブラリの大部分は、UNIX、Windows、およびMacintoshで非常に移植性が高く、クロスプラットフォーム互換です。
• インタラクティブモード-Pythonは、コードのスニペットのインタラクティブなテストとデバッグを可能にするインタラクティブモードをサポートしています。
• ポータブル-Pythonはさまざまなハードウェアプラットフォームで実行でき、すべてのプラットフォームで同じインターフェイスを備えています。
• 拡張可能-Pythonインタープリターに低レベルモジュールを追加できます。 これらのモジュールを使用すると、プログラマはツールを追加またはカスタマイズしてより効率的にすることができます。
• データベース-Pythonは、すべての主要な商用データベースへのインターフェースを提供します。
• * GUIプログラミング*-Pythonは、多くのシステムコール、ライブラリ、Windows MFC、Macintosh、UnixのX WindowシステムなどのWindowsシステムに作成および移植できるGUIアプリケーションをサポートしています。
• スケーラブル-Pythonはシェルスクリプトよりも優れた構造と大規模プログラムのサポートを提供します。

上記の機能とは別に、Pythonには優れた機能の大きなリストがあります。 A、いくつかは以下にリストされています-

• OOPと同様に、機能的および構造的なプログラミング方法をサポートします。
• スクリプト言語として使用することも、大規模なアプリケーションを構築するためにバイトコードにコンパイルすることもできます。
• 非常に高レベルの動的データ型を提供し、動的型チェックをサポートします。
• 自動ガベージコレクションをサポートしています。
• C、C ++、COM、ActiveX、CORBA、およびJavaと簡単に統合できます。

Python 3-環境設定

Python 3は、Windows、Mac OS、およびほとんどの種類のLinuxオペレーティングシステムで使用できます。 Python 2は他の多くのOSで使用可能ですが、Python 3サポートはそれらで使用可能になっていないか、削除されています。

ローカル環境のセットアップ

ターミナルウィンドウを開き、「python」と入力して、既にインストールされているかどうかとインストールされているバージョンを確認します。

Pythonを入手する

Windowsプラットフォーム

最新バージョンのPython 3（Python 3.5.1）のバイナリは、https://www.python.org/downloads/windows/[このダウンロードページ]で入手できます。

次のさまざまなインストールオプションを使用できます。

• Windows x86-64埋め込みzipファイル
• Windows x86-64実行可能インストーラー
• Windows x86-64 Webベースのインストーラー
• Windows x86埋め込みzipファイル
• Windows x86実行可能インストーラー
• Windows x86 Webベースのインストーラー

注-Python 3.5.1をインストールするための最小OS要件は、Windows 7 SP1です。 バージョン3.0から3.4.xでは、Windows XPが許容されます。

Linuxプラットフォーム

Linuxの異なるフレーバーは、新しいパッケージのインストールに異なるパッケージマネージャーを使用します。

Ubuntu Linuxでは、ターミナルから次のコマンドを使用してPython 3がインストールされます。

$sudo apt-get install python3-minimal

ソースからのインストール

PythonのダウンロードURLからGzip圧縮されたソースtarballをダウンロードします-https://www.python.org/ftp/python/3.5.1/Python-3.5.1.tgz

Extract the tarball
tar xvfz Python-3.5.1.tgz
Configure and Install:
cd Python-3.5.1
./configure --prefix =/opt/python3.5.1
make
sudo make install

マックOS

このURLからMac OSインストーラーをダウンロードします-https://www.python.org/downloads/mac-osx/

• Mac OS X 64ビット/32ビットインストーラー-python-3.5.1-macosx10.6.pkg
• Mac OS X 32ビットi386/PPCインストーラー-python-3.5.1-macosx10.5.pkg

このパッケージファイルをダブルクリックし、ウィザードの指示に従ってインストールします。

最新および最新のソースコード、バイナリ、ドキュメント、ニュースなどは、Pythonの公式Webサイトで入手できます-

• Python公式ウェブサイト*-https://www.python.org/

Pythonドキュメントは、次のサイトからダウンロードできます。 ドキュメントは、HTML、PDF、およびPostScript形式で入手できます。

• PythonドキュメントWebサイト*-https://www.python.org/doc/[www.python.org/doc/]

PATHのセットアップ

プログラムおよびその他の実行可能ファイルは、多くのディレクトリに配置できます。 したがって、オペレーティングシステムは、実行可能ファイルを検索するディレクトリをリストする検索パスを提供します。

重要な機能は次のとおりです-

• パスは環境変数に保存されます。環境変数は、オペレーティングシステムによって管理される名前付き文字列です。 この変数には、コマンドシェルおよび他のプログラムで利用可能な情報が含まれています。
• パス変数の名前は、Unixでは PATH 、Windowsでは Path （Unixでは大文字と小文字が区別されますが、Windowsでは区別されません）と呼ばれます。
• Mac OSでは、インストーラーがパスの詳細を処理します。 特定のディレクトリからPythonインタープリターを起動するには、Pythonディレクトリをパスに追加する必要があります。

Unix/Linuxでのパスの設定

Unixで特定のセッションのパスにPythonディレクトリを追加するには-

• * cshシェル*で-setenv PATH "$ PATH：/usr/local/bin/python3"と入力し、Enterを押します。
• * bashシェル（Linux）*で-export PYTHONPATH =/usr/local/bin/python3.4と入力し、Enterを押します。
• * shまたはkshシェル*-PATH = "$ PATH：/usr/local/bin/python3"と入力し、Enterを押します。

注意-/usr/local/bin/python3はPythonディレクトリのパスです。

Windowsでのパスの設定

PythonディレクトリをWindowsの特定のセッションのパスに追加するには-

• コマンドプロンプト-path％path％; C：\ Pythonと入力し、Enterキーを押します。

注意-C：\ PythonはPythonディレクトリのパスです

Python環境変数

Pythonで認識される重要な環境変数を次に示します-

Sr.No.	Variable & Description
1	PYTHONPATH PATHに似た役割を持っています。 この変数は、プログラムにインポートされたモジュールファイルの場所をPythonインタープリターに指示します。 PythonソースライブラリディレクトリとPythonソースコードを含むディレクトリを含める必要があります。 PYTHONPATHは、Pythonインストーラーによって事前設定される場合があります。
2	PYTHONSTARTUP Pythonソースコードを含む初期化ファイルのパスが含まれています。 インタプリタを起動するたびに実行されます。 Unixでは.pythonrc.pyという名前で、ユーティリティをロードしたり、PYTHONPATHを変更したりするコマンドが含まれています。
3	PYTHONCASEOK Windowsでは、importステートメントで大文字と小文字を区別しない最初の一致を見つけるようPythonに指示するために使用されます。 この変数を任意の値に設定して、アクティブにします。
4	PYTHONHOME これは、代替モジュール検索パスです。 通常、モジュールライブラリの切り替えを容易にするために、PYTHONSTARTUPまたはPYTHONPATHディレクトリに埋め込まれます。

Pythonを実行する

Pythonを起動するには3つの異なる方法があります-

インタラクティブ通訳

Pythonは、Unix、DOS、またはコマンドラインインタープリターまたはシェルウィンドウを提供する他のシステムから起動できます。

コマンドラインに python と入力します。

インタラクティブなインタープリターですぐにコーディングを開始します。

$python             # Unix/Linux
or
python%             # Unix/Linux
or
C:>python           # Windows/DOS

ここに利用可能なすべてのコマンドラインオプションのリストがあります-

Sr.No.	Option & Description
1	-d デバッグ出力を提供する
2	-O 最適化されたバイトコードを生成します（.pyoファイルになります）
3	-S 起動時にPythonパスを探すためにインポートサイトを実行しないでください
4	-v 詳細出力（importステートメントの詳細トレース）
5	-X クラスベースの組み込み例外を無効にします（文字列のみを使用）。バージョン1.6から廃止
6	-c cmd cmd文字列として送信されたPythonスクリプトを実行します
7	file 指定されたファイルからPythonスクリプトを実行します

コマンドラインからのスクリプト

Pythonスクリプトは、次の例に示すように、アプリケーションでインタープリターを呼び出すことにより、コマンドラインで実行できます。

$python  script.py          # Unix/Linux
or
python% script.py           # Unix/Linux
or
C:>python script.py         # Windows/DOS

注意-ファイル許可モードで実行が許可されていることを確認してください。

統合開発環境

PythonをサポートするGUIアプリケーションがシステムにある場合、グラフィカルユーザーインターフェイス（GUI）環境からPythonを実行することもできます。

• Unix -IDLEはPython用の最初のUnix IDEです。
• Windows - PythonWin は、Pythonの最初のWindowsインターフェイスであり、GUIを備えたIDEです。
• Macintosh -MacintoshバージョンのPythonとIDLE IDEは、メインWebサイトから入手でき、MacBinaryまたはBinHex’dファイルとしてダウンロードできます。

環境を適切にセットアップできない場合は、システム管理者の助けを借りることができます。 Python環境が適切に設定され、完全に正常に動作することを確認してください。

注-以降の章で示されるすべての例は、Windows 7およびUbuntu Linuxで利用可能なPython 3.4.1バージョンで実行されます。

Pythonプログラミング環境はすでにオンラインで設定されているため、理論を学習している間に利用可能なすべての例をオンラインで実行できます。 サンプルを自由に変更して、オンラインで実行してください。

Python 3-基本構文

Python言語には、Perl、C、およびJavaと多くの類似点があります。 ただし、言語間には明確な違いがあります。

最初のPythonプログラム

さまざまなプログラミングモードでプログラムを実行してみましょう。

インタラクティブモードプログラミング

スクリプトファイルをパラメーターとして渡さずにインタープリターを呼び出すと、次のプロンプトが表示されます-

$ python

Python 3.3.2 (default, Dec 10 2013, 11:35:01)
[GCC 4.6.3] on Linux
Type "help", "copyright", "credits", or "license" for more information.
>>>

On Windows:

Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 24 2015, 22:43:06) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>

Pythonプロンプトで次のテキストを入力し、Enterキーを押します-

>>> print ("Hello, Python!")

古いバージョンのPython（Python 2.x）を実行している場合、 inprint 関数としての括弧の使用はオプションです。 これは、次の結果を生成します-

Hello, Python!

スクリプトモードプログラミング

スクリプトパラメーターでインタープリターを呼び出すと、スクリプトの実行が開始され、スクリプトが終了するまで続行されます。 スクリプトが終了すると、インタープリターはアクティブではなくなります。

スクリプトで簡単なPythonプログラムを作成しましょう。 Pythonファイルの拡張子は .py です。 test.pyファイルに次のソースコードを入力します-

print ("Hello, Python!")

Pythonインタープリターが PATH 変数に設定されていると仮定します。 今、次のようにこのプログラムを実行してみてください-

*Linux* の場合

$ python test.py

これは、次の結果を生成します-

Hello, Python!

*Windows*

C:\Python34>Python test.py

これは、次の結果を生成します-

Hello, Python!

LinuxでPythonスクリプトを実行する別の方法を試してみましょう。 ここに変更されたtest.pyファイルがあります-

#!/usr/bin/python3
print ("Hello, Python!")

Pythonインタープリターが/usr/binディレクトリーで使用可能であると想定しています。 今、次のようにこのプログラムを実行してみてください-

$ chmod +x test.py     # This is to make file executable
$./test.py

これは、次の結果を生成します-

Hello, Python!

Python識別子

Python識別子は、変数、関数、クラス、モジュール、またはその他のオブジェクトを識別するために使用される名前です。 識別子は、文字A〜Zまたはa〜zまたはアンダースコア（_）で始まり、その後にゼロ個以上の文字、アンダースコア、および数字（0〜9）が続きます。

Pythonでは、識別子内で@、$、％などの句読点文字を使用できません。 Pythonは、大文字と小文字を区別するプログラミング言語です。 したがって、 Manpower と manpower はPythonの2つの異なる識別子です。

Python識別子の命名規則は次のとおりです-

• クラス名は大文字で始まります。 他のすべての識別子は小文字で始まります。
• 単一の先頭アンダースコアで識別子を開始することは、識別子がプライベートであることを示します。
• 2つの先頭のアンダースコアで識別子を開始することは、強力なプライベート識別子を示します。
• 識別子の末尾に2つの下線が付いている場合、その識別子は言語定義の特別な名前です。

予約語

次のリストは、Pythonキーワードを示しています。 これらは予約語であり、定数や変数、またはその他の識別子名として使用することはできません。 すべてのPythonキーワードには小文字のみが含まれます。

and	exec	not
as	finally	or
assert	for	pass
break	from	print
class	global	raise
continue	if	return
def	import	try
del	in	while
elif	is	with
else	lambda	yield
except

行とインデント

Pythonは、クラスと関数の定義またはフロー制御のコードブロックを示すために中括弧（\ {}）を使用しません。 コードのブロックは、行のインデントによって示され、厳密に強制されます。

インデント内のスペースの数は可変ですが、ブロック内のすべてのステートメントは同じ量だけインデントする必要があります。 たとえば-

if True:
   print ("True")

else:
   print ("False")

ただし、次のブロックはエラーを生成します-

if True:
   print ("Answer")
   print ("True")

else:
   print "(Answer")
   print ("False")

したがって、Pythonでは、同じ数のスペースでインデントされたすべての連続行がブロックを形成します。 次の例には、さまざまなステートメントブロックがあります-

注-この時点でロジックを理解しようとしないでください。 中括弧がない場合でも、さまざまなブロックを理解していることを確認してください。

#!/usr/bin/python3

import sys

try:
   # open file stream
   file = open(file_name, "w")

except IOError:
   print ("There was an error writing to", file_name)
   sys.exit()
print ("Enter '", file_finish,)
print "' When finished"

while file_text != file_finish:
   file_text = raw_input("Enter text: ")

   if file_text == file_finish:
      # close the file
      file.close
      break
   file.write(file_text)
   file.write("\n")
file.close()
file_name = input("Enter filename: ")

if len(file_name) == 0:
   print ("Next time please enter something")
   sys.exit()

try:
   file = open(file_name, "r")

except IOError:
   print ("There was an error reading file")
   sys.exit()
file_text = file.read()
file.close()
print (file_text)

複数行ステートメント

Pythonのステートメントは通常、新しい行で終わります。 ただし、Pythonでは、行を継続する必要があることを示すために、行継続文字（\）を使用できます。 たとえば-

total = item_one + \
   item_two + \
   item_three

[]、\ {}、または（）の括弧内に含まれるステートメントでは、行継続文字を使用する必要はありません。 たとえば-

days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

Pythonでの引用

Pythonは、同じタイプの引用符が文字列を開始および終了する限り、文字列リテラルを示すために単一（ '）、二重（ "）および三重（' または" ""）引用符を受け入れます。

三重引用符は、複数の行に文字列を広げるために使用されます。 たとえば、以下はすべて合法です-

word = 'word'
sentence = "This is a sentence."
paragraph = """This is a paragraph. It is
made up of multiple lines and sentences."""

Pythonのコメント

文字列リテラル内にないハッシュ記号（＃）は、コメントの始まりです。 ＃の後の物理行の最後までのすべての文字はコメントの一部であり、Pythonインタープリターはそれらを無視します。

#!/usr/bin/python3

# First comment
print ("Hello, Python!") # second comment

これは、次の結果を生成します-

Hello, Python!

あなたは、ステートメントまたは式の後に同じ行にコメントを入力することができます-

name = "Madisetti" # This is again comment

次のように複数の行をコメントすることができます-

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

次の三重引用符で囲まれた文字列もPythonインタープリターによって無視され、複数行のコメントとして使用できます。

This is a multiline
comment.

空白行を使用する

コメントが含まれる可能性がある空白のみを含む行は空白行と呼ばれ、Pythonでは完全に無視されます。

対話型インタープリターセッションでは、空の物理行を入力して複数行ステートメントを終了する必要があります。

ユーザーを待っています

プログラムの次の行は、プロンプトと、「終了するにはEnterキーを押してください」という文を表示し、ユーザーがアクションを実行するのを待ちます-

#!/usr/bin/python3

input("\n\nPress the enter key to exit.")

ここでは、実際の行を表示する前に「\ n \ n」を使用して2つの新しい行を作成します。 ユーザーがキーを押すと、プログラムは終了します。 これは、ユーザーがアプリケーションを終了するまでコンソールウィンドウを開いたままにするための便利な方法です。

単一行の複数のステートメント

セミコロン（;）を使用すると、新しいコードブロックを開始するステートメントがない場合、1行で複数のステートメントを使用できます。 これはセミコロンを使用したサンプルの切り取りです-

import sys; x = 'foo'; sys.stdout.write(x + '\n')

スイートとしての複数のステートメントグループ

単一のコードブロックを作成する個々のステートメントのグループは、Pythonでは*スイート*と呼ばれます。 if、while、def、classなどの複合または複雑なステートメントには、ヘッダー行とスイートが必要です。

ヘッダー行はステートメント（キーワード）で始まり、コロン（：）で終わり、その後にスイートを構成する1つ以上の行が続きます。 たとえば-

if expression :
   suite
elif expression :
   suite
else :
   suite

コマンドライン引数

多くのプログラムを実行して、実行方法に関する基本情報を提供できます。 Pythonでは、- h でこれを行うことができます-

$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit

[ etc. ]

また、さまざまなオプションを受け入れるようにスクリプトをプログラムすることもできます。 link：/python3/python_command_line_arguments [コマンドライン引数]は高度なトピックです。 それを理解しましょう。

Python 3-変数タイプ

変数は、値を保存するために予約されたメモリの場所に他なりません。 つまり、変数を作成するときに、メモリ内にいくらかのスペースを確保します。

変数のデータ型に基づいて、インタプリタはメモリを割り当て、予約メモリに保存できるものを決定します。 したがって、異なるデータ型を変数に割り当てることにより、これらの変数に整数、小数、または文字を格納できます。

変数への値の割り当て

Python変数は、メモリ空間を確保するために明示的な宣言を必要としません。 変数に値を割り当てると、宣言が自動的に行われます。 等号（=）は、変数に値を割り当てるために使用されます。

=演算子の左側のオペランドは変数の名前であり、=演算子の右側のオペランドは変数に格納されている値です。 たとえば-

#!/usr/bin/python3

counter = 100          # An integer assignment
miles   = 1000.0       # A floating point
name    = "John"       # A string

print (counter)
print (miles)
print (name)

ここで、100、1000.0、および「John」は、それぞれcounter、miles、およびname変数に割り当てられる値です。 これは、次の結果を生成します-

100
1000.0
John

複数の割り当て

Pythonでは、単一の値を複数の変数に同時に割り当てることができます。

たとえば-

a = b = c = 1

ここでは、整数オブジェクトが値1で作成され、3つの変数すべてが同じメモリ位置に割り当てられます。 複数のオブジェクトを複数の変数に割り当てることもできます。 たとえば-

a, b, c = 1, 2, "john"

ここでは、値1と2の2つの整数オブジェクトがそれぞれ変数aとbに割り当てられ、値「john」の1つの文字列オブジェクトが変数cに割り当てられます。

標準データ型

メモリに保存されるデータには多くの種類があります。 たとえば、人の年齢は数値として保存され、住所は英数字として保存されます。 Pythonには、さまざまな標準データ型があり、それらを使用して可能な操作とそれぞれの保存方法を定義します。

Pythonには5つの標準データ型があります-

• 番号
• ひも
• List
• タプル
• 辞書

Python番号

数値データ型には数値が格納されます。 数値オブジェクトは、値を割り当てると作成されます。 たとえば-

var1 = 1
var2 = 10

*del* ステートメントを使用して、数値オブジェクトへの参照を削除することもできます。 *del* ステートメントの構文は-

del var1[,var2[,var3[....,varN]]]]

*del* ステートメントを使用して、単一のオブジェクトまたは複数のオブジェクトを削除できます。

たとえば-

del var
del var_a, var_b

Pythonは3つの異なる数値型をサポートしています-

• int（符号付き整数）
• float（浮動小数点の実数値）
• 複素数（複素数）

Python3のすべての整数は、長整数として表されます。 したがって、個別の数値タイプはありません。

例

ここに数字のいくつかの例があります-

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3PLUSe18	.876j
-0490	-90.	-.6545PLUS0J
-0x260	-32.54e100	3ePLUS26J
0x69	70.2-E12	4.53e-7j

複素数は、x＆plus;で表される順序付けられた実浮動小数点数のペアで構成されます。 yj、ここでxとyは実数、jは虚数単位です。

Python文字列

Pythonの文字列は、引用符で表された連続した文字セットとして識別されます。 Pythonでは、単一引用符または二重引用符のペアを使用できます。 文字列のサブセットは、スライス演算子（[]および[：]）を使用して、文字列の先頭の0から始まり、-1から末尾までのインデックスを使用して取得できます。

プラス（＆plus;）記号は文字列連結演算子であり、アスタリスク（*）は繰り返し演算子です。 たとえば-

#!/usr/bin/python3

str = 'Hello World!'

print (str)          # Prints complete string
print (str[0])       # Prints first character of the string
print (str[2:5])     # Prints characters starting from 3rd to 5th
print (str[2:])      # Prints string starting from 3rd character
print (str * 2)      # Prints string two times
print (str + "TEST") # Prints concatenated string

これは、次の結果を生成します-

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

Pythonリスト

リストは、Pythonの複合データ型の中で最も汎用性があります。 リストには、コンマで区切られ、角括弧（[]）で囲まれたアイテムが含まれます。 ある程度、リストはCの配列に似ています。 それらの違いの1つは、リストに属するすべてのアイテムが異なるデータ型である可能性があることです。

リストに格納された値は、リストの先頭の0から始まり、-1の終わりまでインデックスを使用して、スライス演算子（[]および[：]）を使用してアクセスできます。 プラス（＆plus;）記号はリスト連結演算子であり、アスタリスク（*）は繰り返し演算子です。 たとえば-

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print (list)          # Prints complete list
print (list[0])       # Prints first element of the list
print (list[1:3])     # Prints elements starting from 2nd till 3rd
print (list[2:])      # Prints elements starting from 3rd element
print (tinylist * 2)  # Prints list two times
print (list + tinylist) # Prints concatenated lists

これは、次の結果を生成します-

['abcd', 786, 2.23, 'john', 70.200000000000003]
abcd
[786, 2.23]
[2.23, 'john', 70.200000000000003]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']

Pythonタプル

タプルは、リストに類似した別のシーケンスデータ型です。 タプルは、コンマで区切られた多数の値で構成されます。 ただし、リストとは異なり、タプルは括弧で囲まれています。

リストとタプルの主な違いは次のとおりです。-リストは括弧（[]）で囲まれ、その要素とサイズは変更できますが、タプルは括弧（（））で囲まれ、更新できません。 タプルは*読み取り専用*リストと考えることができます。 たとえば-

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
tinytuple = (123, 'john')

print (tuple)           # Prints complete tuple
print (tuple[0])        # Prints first element of the tuple
print (tuple[1:3])      # Prints elements starting from 2nd till 3rd
print (tuple[2:])       # Prints elements starting from 3rd element
print (tinytuple *2)   # Prints tuple two times
print (tuple + tinytuple) # Prints concatenated tuple

これは、次の結果を生成します-

('abcd', 786, 2.23, 'john', 70.200000000000003)
abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

許可されていないタプルを更新しようとしたため、次のコードはタプルでは無効です。 リストで同様のケースが可能です-

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
list = [ 'abcd', 786 , 2.23, 'john', 70.2  ]
tuple[2] = 1000    # Invalid syntax with tuple
list[2] = 1000     # Valid syntax with list

Python辞書

Pythonの辞書は一種のハッシュテーブル型です。 Perlにある連想配列またはハッシュのように機能し、キーと値のペアで構成されます。 辞書キーはほぼすべてのPythonタイプにできますが、通常は数字または文字列です。 一方、値は任意のPythonオブジェクトにすることができます。

辞書は中括弧（\ {}）で囲まれ、値は、中括弧（[]）を使用して割り当ておよびアクセスできます。 たとえば-

#!/usr/bin/python3

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print (dict['one'])       # Prints value for 'one' key
print (dict[2])           # Prints value for 2 key
print (tinydict)          # Prints complete dictionary
print (tinydict.keys())   # Prints all the keys
print (tinydict.values()) # Prints all the values

これは、次の結果を生成します-

This is one
This is two
{'name': 'john', 'dept': 'sales', 'code': 6734}
dict_keys(['name', 'dept', 'code'])
dict_values(['john', 'sales', 6734])

辞書には、要素間の順序の概念はありません。 要素が「順不同」であると言うのは誤りです。それらは単純に順不同です。

データ型変換

場合によっては、組み込み型の間で変換を実行する必要があります。 型を変換するには、単に型名を関数として使用します。

あるデータ型から別のデータ型への変換を実行するための組み込み関数がいくつかあります。 これらの関数は、変換された値を表す新しいオブジェクトを返します。

Sr.No.	Function & Description
1	int(x [,base])* xを整数に変換します。 xが文字列の場合、baseはベースを指定します。
2	float(x) xを浮動小数点数に変換します。
3	complex(real [,imag]) 複素数を作成します。
4	str(x) オブジェクトxを文字列表現に変換します。
5	repr(x) オブジェクトxを式文字列に変換します。
6	eval(str) 文字列を評価し、オブジェクトを返します。
7	tuple(s) sをタプルに変換します。
8	list(s) sをリストに変換します。
9	set(s) sをセットに変換します。
10	dict(d) 辞書を作成します。 dは（key、value）タプルのシーケンスでなければなりません。
11	frozenset(s) sをフリーズセットに変換します。
12	chr(x) 整数を文字に変換します。
13	unichr(x) 整数をUnicode文字に変換します。
14	ord(x) 単一の文字を整数値に変換します。
15	hex(x) 整数を16進数の文字列に変換します。
16	oct(x) 整数を8進数の文字列に変換します。

Python 3-基本演算子

演算子は、オペランドの値を操作できる構造です。 式4＆plus;を検討してください。 5 = 9。 ここで、4と5はオペランドと呼ばれ、＆plus;演算子と呼ばれます。

オペレーターの種類

Python言語は、演算子の次のタイプをサポートしています-

• 算術演算子
• 比較（関係）演算子
• 割り当て演算子
• 論理演算子
• ビット演算子
• 会員オペレーター
• アイデンティティ演算子

すべての演算子を1つずつ見てみましょう。

Pythonの算術演算子

変数 a が値10を保持し、変数 b が値21を保持すると仮定します-

link：/python3/arithmetic_operators_example [例を表示]

Operator	Description	Example
PLUS Addition	Adds values on either side of the operator.	a PLUS b = 31
- Subtraction	Subtracts right hand operand from left hand operand.	a – b = -11
*Multiplication	Multiplies values on either side of the operator	a* b = 210
/Division	Divides left hand operand by right hand operand	b/a = 2.1
% Modulus	Divides left hand operand by right hand operand and returns remainder	b % a = 1
** Exponent	Performs exponential (power) calculation on operators	a**b =10 to the power 20
//	Floor Division - The division of operands where the result is the quotient in which the digits after the decimal point are removed. But if one of the operands is negative, the result is floored, i.e., rounded away from zero (towards negative infinity):	9//2 = 4 and 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0

Python比較演算子

これらの演算子は、それらの両側の値を比較し、それらの間の関係を決定します。 関係演算子とも呼ばれます。

変数 a が値10を保持し、変数 b が値20を保持すると仮定します-

link：/python3/comparison_operators_example [例を表示]

Operator	Description	Example
==	If the values of two operands are equal, then the condition becomes true.	(a == b) is not true.
!=	If values of two operands are not equal, then condition becomes true.	(a!= b) is true.
>	If the value of left operand is greater than the value of right operand, then condition becomes true.	(a > b) is not true.
<	If the value of left operand is less than the value of right operand, then condition becomes true.	(a < b) is true.
>=	If the value of left operand is greater than or equal to the value of right operand, then condition becomes true.	(a >= b) is not true.
⇐	If the value of left operand is less than or equal to the value of right operand, then condition becomes true.	(a ⇐ b) is true.

Python割り当て演算子

変数 a が値10を保持し、変数 b が値20を保持すると仮定します-

link：/python3/assignment_operators_example [例を表示]

Operator	Description	Example
=	Assigns values from right side operands to left side operand	c = a PLUS b assigns value of a PLUS b into c
PLUS= Add AND	It adds right operand to the left operand and assign the result to left operand	c PLUS= a is equivalent to c = c PLUS a
-= Subtract AND	It subtracts right operand from the left operand and assign the result to left operand	c -= a is equivalent to c = c - a
*= Multiply AND	It multiplies right operand with the left operand and assign the result to left operand	c *= a is equivalent to c = c * a
/= Divide AND	It divides left operand with the right operand and assign the result to left operand	c/= a is equivalent to c = c/ac/= a is equivalent to c = c/a
%= Modulus AND	It takes modulus using two operands and assign the result to left operand	c %= a is equivalent to c = c % a
**= Exponent AND	Performs exponential (power) calculation on operators and assign value to the left operand	c = a is equivalent to c = c a
//= Floor Division	It performs floor division on operators and assign value to the left operand	c//= a is equivalent to c = c//a

Pythonビット単位演算子

ビット演算子はビットに対して機能し、ビットごとの操作を実行します。 a = 60の場合;およびb = 13;今バイナリ形式では、次のようになります-

a = 0011 1100

b = 0000 1101

a＆b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

〜a = 1100 0011

Pythonの組み込み関数bin（）を使用して、整数のバイナリ表現を取得できます。

次のビットごとの演算子は、Python言語でサポートされています-

link：/python3/bitwise_operators_example [例を表示]

[cols=",,",options="header",]
|===
|Operator |Description |Example |& Binary AND |Operator copies a bit, to the result, if it exists in both operands |(a & b) (means 0000 1100) || Binary OR |It copies a bit, if it exists in either operand. |(a | b) = 61 (means 0011 1101) |^ Binary XOR |It copies the bit, if it is set in one operand but not both. |(a ^ b) = 49 (means 0011 0001) |~ Binary Ones Complement |It is unary and has the effect of 'flipping' bits. |(~a ) = -61 (means 1100 0011 in 2's complement form due to a signed binary number. |<< Binary Left Shift |The left operand's value is moved left by the number of bits specified by the right operand. |a << 2 = 240 (means 1111 0000) |>> Binary Right Shift |The left operand's value is moved right by the number of bits specified by the right operand. |a >> 2 = 15 (means 0000 1111)
|===

=== Python論理演算子

Python言語では、次の論理演算子がサポートされています。 変数 *a* がTrueを保持し、変数 *b* がFalseを保持すると仮定します-

link：/python3/logical_operators_example [例を表示]

[cols=",,",options="header",]
|===
|Operator |Description |Example |and Logical AND |If both the operands are true then condition becomes true. |(a and b) is False. |or Logical OR |If any of the two operands are non-zero then condition becomes true. |(a or b) is True. |not Logical NOT |Used to reverse the logical state of its operand. |Not(a and b) is True.
|===

=== Pythonメンバーシップオペレーター

Pythonのメンバーシップ演算子は、文字列、リスト、タプルなどのシーケンスのメンバーシップをテストします。 以下に説明するように2つのメンバーシップ演算子があります-

link：/python3/membership_operators_example [例を表示]

[cols=",,",options="header",]
|===
|Operator |Description |Example |in |Evaluates to true if it finds a variable in the specified sequence and false otherwise. |x in y, here in results in a 1 if x is a member of sequence y. |not in |Evaluates to true if it does not finds a variable in the specified sequence and false otherwise. |x not in y, here not in results in a 1 if x is not a member of sequence y.
|===

=== Python IDオペレーター

アイデンティティ演算子は、2つのオブジェクトのメモリ位置を比較します。 以下に説明するように、2つのアイデンティティ演算子があります-

link：/python3/identity_operators_example [例を表示]

[cols=",,",options="header",]
|===
|Operator |Description |Example |is |Evaluates to true if the variables on either side of the operator point to the same object and false otherwise. |x is y, here *is *results in 1 if id(x) equals id(y). |is not |Evaluates to false if the variables on either side of the operator point to the same object and true otherwise. |x is not y, here* is not* results in 1 if id(x) is not equal to id(y).
|===

=== Python演算子の優先順位

次の表に、優先順位の高いものから低いものまでのすべての演算子を示します。

link：/python3/operators_precedence_example [例を表示]

[width="100%",cols="50%,50%",options="header",]
|===
|Sr.No. |Operator & Description |1 a|
**** ****

べき乗（累乗）

|2 a| *~ &plus; -*

補数、単項プラスおよびマイナス（最後の2つのメソッド名は+ @および-@）

|3 a|
 */％//*

乗算、除算、モジュロ、およびフロア除算

|4 a| *&plus; -*

加減

|5 a| *>> <<*

左右のビット単位シフト

|6 a| *&*

ビット単位の「AND」

|7 a| *^ |*

ビット単位の排他的な「OR」および通常の「OR」

|8 a| *<= < > >=*

比較演算子

|9 a| *<> == !=*

平等演算子

|10 a| *= %=/=//= -= &plus;= *= **=*

割り当て演算子

|11 a| *is is not*

アイデンティティ演算子

|12 a| *in not in*

会員事業者

|13 a| *not or and*

論理演算子

|===

Python 3-意思決定

意思決定とは、プログラムの実行中に発生する条件を予測し、その条件に従って特定のアクションを実行することです。

決定構造は、結果としてTRUEまたはFALSEを生成する複数の式を評価します。 結果がTRUEまたはFALSEの場合、実行するアクションと実行するステートメントを決定する必要があります。

以下は、ほとんどのプログラミング言語で見られる典型的な意思決定構造の一般的な形式です-

意思決定

Pythonプログラミング言語は、非ゼロ*および*非ヌル*値をTRUE、および*ゼロ*または NULL値*をFALSE値とみなします。

Pythonプログラミング言語は、次のタイプの意思決定ステートメントを提供します。

Sr.No.	Statement & Description
1	if statements ifステートメント*は、ブール式とそれに続く1つ以上のステートメントで構成されます。
2	if…​else statements ifステートメント*の後にオプションの* elseステートメント*を続けることができます。これはブール式がFALSEの場合に実行されます。
3	nested if statements 1つの if または else if ステートメントを別の if または else if ステートメント内で使用できます。

各意思決定ステートメントをすばやく見てみましょう。

シングルステートメントスイート

*if* 句のスイートが1行のみで構成される場合、ヘッダーステートメントと同じ行に配置できます。

例

以下は、 one-line if 句の例です-

#!/usr/bin/python3

var = 100
if ( var  == 100 ) : print ("Value of expression is 100")
print ("Good bye!")

出力

上記のコードが実行されると、次の結果が生成されます-

Value of expression is 100
Good bye!

Python 3-ループ

一般に、ステートメントは順番に実行されます-関数内の最初のステートメントが最初に実行され、次に2番目のステートメントが実行されます。 コードのブロックを数回実行する必要がある場合があります。

プログラミング言語は、より複雑な実行パスを可能にするさまざまな制御構造を提供します。

ループステートメントを使用すると、ステートメントまたはステートメントのグループを複数回実行できます。 次の図は、ループ文を示しています-

ループアーキテクチャ

Pythonプログラミング言語は、ループ要件を処理するために次のタイプのループを提供します。

Sr.No.	Loop Type & Description
1	while loop 特定の条件がTRUEの間、ステートメントまたはステートメントのグループを繰り返します。 ループ本体を実行する前に条件をテストします。
2	for loop 一連のステートメントを複数回実行し、ループ変数を管理するコードを短縮します。
3	nested loops whileまたはforループの中で、1つ以上のループを別のループ内で使用できます。

ループ制御ステートメント

ループ制御ステートメントは、通常のシーケンスから実行を変更します。 実行がスコープを離れると、そのスコープで作成されたすべての自動オブジェクトは破棄されます。

Pythonは、次の制御ステートメントをサポートしています。

Sr.No.	Control Statement & Description
1	break statement ループステートメントを終了し、ループの直後のステートメントに実行を転送します。
2	continue statement ループがその本体の残りをスキップし、反復する前にその状態をすぐに再テストします。
3	pass statement Pythonのpassステートメントは、ステートメントが構文的に必要であるが、コマンドやコードを実行したくない場合に使用されます。

ループ制御ステートメントを簡単に見てみましょう。

イテレータとジェネレータ

*Iterator* は、特定の実装に関係なく、プログラマーがコレクションのすべての要素を走査できるようにするオブジェクトです。 Pythonでは、イテレータオブジェクトは2つのメソッド、* iter（）*および* next（）*を実装します。

String、List、またはTupleオブジェクトを使用して、イテレーターを作成できます。

list = [1,2,3,4]
it = iter(list) # this builds an iterator object
print (next(it)) #prints next available element in iterator
Iterator object can be traversed using regular for statement
!usr/bin/python3
for x in it:
   print (x, end=" ")
or using next() function
while True:
   try:
      print (next(it))
   except StopIteration:
      sys.exit() #you have to import sys module for this

*generator* は、yieldメソッドを使用して値のシーケンスを生成または生成する関数です。

ジェネレーター関数が呼び出されると、関数の実行を開始することなくジェネレーターオブジェクトを返します。 next（）メソッドが最初に呼び出されると、関数はyieldステートメントに到達するまで実行を開始し、yield値が返されます。 利回りは追跡を続けます。 最後の実行を記憶し、2番目のnext（）呼び出しは前の値から継続します。

例

次の例では、すべてのフィボナッチ数の反復子を生成するジェネレーターを定義しています。

#!usr/bin/python3

import sys
def fibonacci(n): #generator function
   a, b, counter = 0, 1, 0
   while True:
      if (counter > n):
         return
      yield a
      a, b = b, a + b
      counter += 1
f = fibonacci(5) #f is iterator object

while True:
   try:
      print (next(f), end=" ")
   except StopIteration:
      sys.exit()

Python 3-数字

数値データ型には数値が格納されます。 それらは不変のデータ型です。 つまり、数値データ型の値を変更すると、新しく割り当てられたオブジェクトになります。

数値オブジェクトは、値を割り当てると作成されます。 たとえば-

var1 = 1
var2 = 10

*del* ステートメントを使用して、数値オブジェクトへの参照を削除することもできます。 *del* ステートメントの構文は-

del var1[,var2[,var3[....,varN]]]]

*del* ステートメントを使用して、単一のオブジェクトまたは複数のオブジェクトを削除できます。 たとえば-

del var
del var_a, var_b

Pythonはさまざまな数値型をサポートしています-

• * int（符号付き整数）-多くの場合、単に整数または *ints と呼ばれます。 それらは、小数点のない正または負の整数です。 Python 3の整数のサイズは無制限です。 Python 2には、int型とlong型の2つの整数型があります。 Python 3には「 long integer 」はもうありません。
• * float（浮動小数点の実数値）*-floatとも呼ばれ、実数を表し、整数部と小数部を分割する小数点で記述されます。 浮動小数点数は科学表記法でもあり、Eまたはeは10の累乗を示します（2.5e2 = 2.5 x 10 ^ 2 ^ = 250）。
• * complex（complex numbers）*-はa + bJの形式です。aとbはfloatで、J（またはj）は-1（虚数）の平方根を表します。 数の実部はaで、虚部はbです。 Pythonプログラミングでは複素数はあまり使用されません。

整数を16進数または8進数形式で表すことができます。

>>> number = 0xA0F #Hexa-decimal
>>> number
2575

>>> number = 0o37 #Octal
>>> number
31

例

数値の例を次に示します。

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3PLUSe18	.876j
-0490	-90.	-.6545PLUS0J
-0×260	-32.54e100	3ePLUS26J
0×69	70.2-E12	4.53e-7j

複素数は、＆plus;で示される実浮動小数点数の順序付きペアで構成されます。 bj。ここで、aは実数部、bは複素数の虚数部です。

数値型変換

Pythonは、混合型を含む式の数値を評価のために共通の型に内部的に変換します。 場合によっては、演算子または関数のパラメーターの要件を満たすために、あるタイプから別のタイプに明示的に数値を強制する必要があります。

• xをプレーン整数に変換するには、* int（x）*と入力します。
• * long（x）*と入力して、xを長整数に変換します。
• * float（x）*と入力して、xを浮動小数点数に変換します。
• * complex（x）*と入力して、xを実部xと虚部0の複素数に変換します。
• * complex（x、y）*と入力して、xとyを実数部xと虚数部yの複素数に変換します。 xとyは数値式です

数学関数

Pythonには、数学計算を実行する次の関数が含まれています。

Sr.No.	Function & Returns ( Description )
1	abs(x) xの絶対値：xとゼロの間の（正の）距離。
2	ceil(x) xの上限：x以上の最小整数。
3	cmp(x, y) x <yの場合は-1、x == yの場合は0、x> yの場合は1。 非推奨 Python 3。 代わりに* return（x> y）-（x <y）*を使用してください。
4	exp(x) xの指数：e ^ x ^
5	fabs(x) xの絶対値。
6	floor(x) xの下限：x以下の最大整数。
7	log(x) x> 0の場合のxの自然対数。
8	log10(x) x> 0の場合のxの10を底とする対数。
9	max(x1, x2,…​) 引数の最大値：正の無限大に最も近い値
10	min(x1, x2,…​) 引数の最小値：負の無限大に最も近い値。
11	modf(x) 2項目タプルのxの小数部と整数部。 両方の部分にxと同じ符号が付いています。 整数部分は浮動小数点数として返されます。
12	pow(x, y) x ** yの値。
13	round(x [,n)] x* 小数点からn桁に丸められます。 Pythonはタイブレーカーとしてゼロから切り捨てます：round（0.5）は1.0で、round（-0.5）は-1.0です。
14	sqrt(x) x> 0の場合のxの平方根。

乱数関数

乱数は、ゲーム、シミュレーション、テスト、セキュリティ、およびプライバシーアプリケーションに使用されます。 Pythonには、一般的に使用される次の関数が含まれています。

Sr.No.	Function & Description
1	choice(seq) リスト、タプル、または文字列からのランダムなアイテム。
2	randrange ([start, stop [,step])] 範囲（開始、停止、ステップ）からランダムに選択された要素。
3	random() 0がr以下で、rが1未満であるようなランダムフロートr
4	seed([x)] 乱数の生成に使用される整数の開始値を設定します。 他のランダムモジュール関数を呼び出す前に、この関数を呼び出します。 Noneを返します。
5	shuffle(lst) 所定の位置にあるリストのアイテムをランダム化します。 Noneを返します。
6	uniform(x, y) xがr以下で、rがyより小さいランダムなフロートr。

三角関数

Pythonには、三角法計算を実行する次の関数が含まれています。

Sr.No.	Function & Description
1	acos(x) ラジアンでxのアークコサインを返します。
2	asin(x) ラジアンでxの逆正弦を返します。
3	atan(x) ラジアンでxのアークタンジェントを返します。
4	atan2(y, x) ラジアンでatan（y/x）を返します。
5	cos(x) xラジアンのコサインを返します。
6	hypot(x, y) ユークリッドノルムsqrt（x x + y y）を返します。
7	sin(x) xラジアンのサインを返します。
8	tan(x) xラジアンのタンジェントを返します。
9	degrees(x) 角度xをラジアンから度に変換します。
10	radians(x) 角度xを度からラジアンに変換します。

数学定数

モジュールはまた、2つの数学定数を定義します-

Sr.No.	Constants & Description
1	pi 数学定数pi。
2	e 数学定数e。

Python 3-文字列

文字列は、Pythonで最も人気のある型の1つです。 文字を引用符で囲むだけで簡単に作成できます。 Pythonは、単一引用符を二重引用符と同様に扱います。 文字列の作成は、変数に値を割り当てるのと同じくらい簡単です。 たとえば-

var1 = 'Hello World!'
var2 = "Python Programming"

文字列の値へのアクセス

Pythonは文字タイプをサポートしていません。これらは長さ1の文字列として扱われるため、部分文字列とも見なされます。

部分文字列にアクセスするには、スライスに角括弧を使用してインデックスを作成し、部分文字列を取得します。 たとえば-

#!/usr/bin/python3

var1 = 'Hello World!'
var2 = "Python Programming"

print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

上記のコードが実行されると、次の結果が生成されます-

var1[0]:  H
var2[1:5]:  ytho

文字列の更新

変数を別の文字列に（再）割り当てることにより、既存の文字列を「更新」できます。 新しい値は、以前の値またはまったく異なる文字列に関連付けることができます。 たとえば-

#!/usr/bin/python3

var1 = 'Hello World!'
print ("Updated String :- ", var1[:6] + 'Python')

上記のコードが実行されると、次の結果が生成されます-

Updated String :-  Hello Python

エスケープ文字

次の表は、バックスラッシュ表記で表現できるエスケープ文字または非印刷文字のリストです。

エスケープ文字が解釈されます。単一引用符と二重引用符で囲まれた文字列で。

Backslash notation	Hexadecimal character	Description
\a	0x07	Bell or alert
\b	0x08	Backspace
\cx		Control-x
\C-x		Control-x
\e	0x1b	Escape
\f	0x0c	Formfeed
\M-\C-x		Meta-Control-x
\n	0x0a	Newline
\nnn		Octal notation, where n is in the range 0.7
\r	0x0d	Carriage return
\s	0x20	Space
\t	0x09	Tab
\v	0x0b	Vertical tab
\x		Character x
\xnn		Hexadecimal notation, where n is in the range 0.9, a.f, or A.F

文字列特殊演算子

文字列変数 a が 'Hello’を保持し、変数 b が 'Python’を保持すると仮定します-

Operator	Description	Example
PLUS	Concatenation - Adds values on either side of the operator	a PLUS b will give HelloPython
*	Repetition - Creates new strings, concatenating multiple copies of the same string	a*2 will give -HelloHello
[]	Slice - Gives the character from the given index	a[1] will give e
[ : ]	Range Slice - Gives the characters from the given range	a[1:4] will give ell
in	Membership - Returns true if a character exists in the given string	H in a will give 1
not in	Membership - Returns true if a character does not exist in the given string	M not in a will give 1
r/R	Raw String - Suppresses actual meaning of Escape characters. The syntax for raw strings is exactly the same as for normal strings with the exception of the raw string operator, the letter "r," which precedes the quotation marks. The "r" can be lowercase (r) or uppercase ® and must be placed immediately preceding the first quote mark.	print r'\n' prints \n and print R'\n’prints \n
%	Format - Performs String formatting	See at next section

文字列フォーマット演算子

Pythonの最も優れた機能の1つは、文字列形式演算子％です。 この演算子は文字列に固有であり、Cのprintf（）ファミリーの関数を含むパックを補います。 以下は簡単な例です-

#!/usr/bin/python3

print ("My name is %s and weight is %d kg!" % ('Zara', 21))

上記のコードが実行されると、次の結果が生成されます-

My name is Zara and weight is 21 kg!

以下は、％とともに使用できるシンボルの完全なセットのリストです-

Sr.No.	Format Symbol & Conversion
1	%c キャラクター
2	%s フォーマット前のstr（）による文字列変換
3	%i 符号付き10進整数
4	%d 符号付き10進整数
5	%u 符号なし10進整数
6	%o 8進整数
7	%x 16進整数（小文字）
8	%X 16進整数（大文字）
9	%e 指数表記（小文字の「e」付き）
10	%E 指数表記（大文字の 'E’を使用）
11	%f 浮動小数点実数
12	%g ％fと％eのうち短い方
13	%G ％fと％Eのうち短い方

他のサポートされている記号と機能は、次の表に記載されています-

Sr.No.	Symbol & Functionality
1	引数は幅または精度を指定します
2	- 左揃え
3	PLUS サインを表示する
4	<sp> 正の数の前に空白を残します
5	# 'x’または 'X’が使用されたかどうかに応じて、8進数の先頭のゼロ（ '0'）または16進数の先頭の '0x’または '0X’を追加します。
6	0 （スペースの代わりに）左からゼロを埋める
7	% 「%%」は、単一のリテラル「％」を残します
8	(var) マッピング変数（辞書引数）
9	m.n. mは最小合計幅、nは小数点の後に表示する桁数です（appl。の場合）。

トリプルクォート

Pythonのトリプルクォートは、文字列が逐語的な改行、TAB、およびその他の特殊文字を含む複数行にまたがることを可能にすることにより、助けになります。

三重引用符の構文は、3つの連続した*単一引用符または二重引用符で構成されます。

#!/usr/bin/python3

para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ \n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print (para_str)

上記のコードが実行されると、次の結果が生成されます。 「up」の間の文字列の最後にある最後の改行まで、すべての特殊文字がどのように印刷形式に変換されたかに注意してください。トリプルクォートを閉じます。 また、改行は、行の末尾に明示的な改行が含まれているか、エスケープコード（\ n）が付いていることに注意してください-

this is a long string that is made up of
several lines and non-printable characters such as
TAB (    ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [
 ], or just a NEWLINE within
the variable assignment will also show up.

生の文字列は、バックスラッシュを特殊文字としてまったく扱いません。 あなたが生の文字列に入れたすべての文字は、それを書いたままです-

#!/usr/bin/python3

print ('C:\\nowhere')

上記のコードが実行されると、次の結果が生成されます-

C:\nowhere

それでは、生の文字列を利用しましょう。 次のように式を* r’expression '*に入れます-

#!/usr/bin/python3

print (r'C:\\nowhere')

上記のコードが実行されると、次の結果が生成されます-

C:\\nowhere

Unicode文字列

Python 3では、すべての文字列はUnicodeで表されます。Python2では、8ビットASCIIとして内部的に保存されるため、「u」を付加してUnicodeにする必要があります。 今はもう必要ありません。

組み込みの文字列メソッド

Pythonには、文字列を操作するための次の組み込みメソッドが含まれています-

Sr.No.	Methods & Description
1	capitalize() 文字列の最初の文字を大文字にします
2	center(width, fillchar) _fillchar_でパディングされた文字列を返します。元の文字列は_width_列の中央に配置されます。
3	count(str 開始インデックスの開始と終了インデックスの終了が指定されている場合、文字列または文字列の部分文字列でstrが発生する回数をカウントします。
4	decode(encoding = 'UTF-8' エンコード用に登録されたコーデックを使用して文字列をデコードします。 エンコーディングのデフォルトはデフォルトの文字列エンコーディングです。
5	encode(encoding = 'UTF-8' 文字列のエンコードされた文字列バージョンを返します。エラーが発生した場合、デフォルトでは、「ignore」または「replace」でエラーが指定されない限り、ValueErrorが発生します。
6	endswith(suffix 文字列または文字列の部分文字列（開始インデックスの開始と終了インデックスの終了が指定されている場合）がサフィックスで終了するかどうかを決定します。そうであればtrueを、そうでなければfalseを返します。
7	expandtabs(tabsize = 8) 文字列のタブを複数のスペースに展開します。 tabsizeが指定されていない場合、タブごとにデフォルトで8スペースが使用されます。
8	find(str 開始インデックスbegと終了インデックスendが指定されている場合、strがstringまたはstringのサブストリングにあるかどうかを判別します。見つかった場合はindexを返し、見つからない場合は-1を返します。
9	index(str find（）と同じですが、strが見つからない場合は例外が発生します。
10	isalnum() 文字列が少なくとも1文字で、すべての文字が英数字の場合はtrueを返し、それ以外の場合はfalseを返します。
11	isalpha() 文字列に少なくとも1文字が含まれ、すべての文字がアルファベットである場合はtrueを返し、そうでない場合はfalseを返します。
12	isdigit() 文字列に数字のみが含まれる場合はtrueを、それ以外の場合はfalseを返します。
13	islower() 文字列に少なくとも1つの大文字と小文字が含まれ、すべての大文字と小文字が小文字の場合はtrueを返し、そうでない場合はfalseを返します。
14	isnumeric() Unicode文字列に数字のみが含まれる場合はtrueを、それ以外の場合はfalseを返します。
15	isspace() 文字列に空白文字のみが含まれる場合はtrueを、それ以外の場合はfalseを返します。
16	istitle() 文字列が適切に「タイトルケース化」されている場合はtrue、そうでない場合はfalseを返します。
17	isupper() 文字列に大文字と小文字が少なくとも1つあり、すべての大文字と小文字が大文字の場合はtrue、そうでない場合はfalseを返します。
18	join(seq) シーケンスseqの要素の文字列表現を、セパレータ文字列を使用して文字列にマージ（連結）します。
19	len(string) 文字列の長さを返します
20	ljust(width[, fillchar)] 幅の列の合計に合わせて元の文字列を左寄せした、スペースが埋め込まれた文字列を返します。
21	lower() 文字列内のすべての大文字を小文字に変換します。
22	lstrip() 文字列の先頭の空白をすべて削除します。
23	maketrans() 変換機能で使用される変換テーブルを返します。
24	max(str) 文字列strからアルファベットの最大文字を返します。
25	min(str) 文字列strからアルファベットの最小文字を返します。
26	replace(old, new [, max)] string内のoldのすべての出現を、maxが指定されている場合、新規または最大max個の出現に置き換えます。
27	rfind(str find（）と同じですが、文字列を逆方向に検索します。
28	rindex( str index（）と同じですが、文字列を逆方向に検索します。
29	rjust(width,[, fillchar)] 幅の列の合計に合わせて右揃えされた元の文字列をスペースで埋めた文字列を返します。
30	rstrip() 文字列の末尾の空白をすべて削除します。
31	split(str="" 区切り文字str（指定されていない場合はスペース）に従って文字列を分割し、部分文字列のリストを返します。指定された場合、最大num個の部分文字列に分割されます。
32	splitlines( num=string.count('\n')) 文字列をすべて（またはnum）個の改行で分割し、改行を削除した各行のリストを返します。
33	startswith(str 文字列または文字列の部分文字列（開始インデックスの開始と終了インデックスの終了が指定されている場合）が部分文字列strで始まるかどうかを決定します。そうであればtrueを、そうでなければfalseを返します。
34	strip([chars)] 文字列に対してlstrip（）とrstrip（）の両方を実行します
35	swapcase() 文字列内のすべての文字の大文字と小文字を逆にします。
36	title() 文字列の「タイトルケース」バージョンを返します。つまり、すべての単語は大文字で始まり、残りは小文字です。
37	translate(table 変換テーブルstr（256文字）に従って文字列を変換し、del文字列内の文字列を削除します。
38	upper() 文字列の小文字を大文字に変換します。
39	zfill (width) 幅の文字の合計までゼロで左詰めされた元の文字列を返します。数値用に、zfill（）は与えられた符号を保持します（ゼロが1つ未満）。
40	isdecimal() Unicode文字列に小数点文字のみが含まれる場合はtrueを、それ以外の場合はfalseを返します。

Python 3-リスト

Pythonで最も基本的なデータ構造は sequence です。 シーケンスの各要素には番号が割り当てられます-その位置またはインデックス。 最初のインデックスはゼロ、2番目のインデックスは1などです。

Pythonには6つの組み込みタイプのシーケンスがありますが、最も一般的なものはリストとタプルであり、これはこのチュートリアルで見ることができます。

すべてのシーケンスタイプでできることがいくつかあります。 これらの操作には、インデックスの作成、スライス、追加、乗算、およびメンバーシップの確認が含まれます。 さらに、Pythonには、シーケンスの長さを検索し、その最大要素と最小要素を検索するための組み込み関数があります。

Pythonリスト

このリストは、Pythonで使用できる最も用途の広いデータ型であり、角括弧で囲まれたコンマ区切り値（アイテム）のリストとして記述できます。 リストに関する重要なことは、リスト内のアイテムが同じタイプである必要はないということです。

リストの作成は、角括弧の間に異なるコンマ区切り値を入れるのと同じくらい簡単です。 たとえば-

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

文字列インデックスと同様に、リストインデックスは0から始まり、リストのスライス、連結などが可能です。

リストの値へのアクセス

リスト内の値にアクセスするには、スライスに角かっこを使用してインデックスを作成し、そのインデックスで使用可能な値を取得します。 たとえば-

#!/usr/bin/python3

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]

print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

上記のコードが実行されると、次の結果が生成されます-

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

リストを更新する

リストの単一または複数の要素を更新するには、代入演算子の左側にスライスを指定し、append（）メソッドを使用してリスト内の要素に追加できます。 たとえば-

#!/usr/bin/python3

list = ['physics', 'chemistry', 1997, 2000]
print ("Value available at index 2 : ", list[2])

list[2] = 2001
print ("New value available at index 2 : ", list[2])

注-append（）メソッドについては、後続のセクションで説明します。

上記のコードが実行されると、次の結果が生成されます-

Value available at index 2 :  1997
New value available at index 2 :  2001

リスト要素を削除

リスト要素を削除するには、削除する要素が正確にわかっている場合は、 del ステートメントを使用できます。 削除するアイテムが正確にわからない場合は、remove（）メソッドを使用できます。 たとえば-

#!/usr/bin/python3

list = ['physics', 'chemistry', 1997, 2000]
print (list)

del list[2]
print ("After deleting value at index 2 : ", list)

上記のコードが実行されると、次の結果が生成されます-

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :  ['physics', 'chemistry', 2000]

注意-remove（）メソッドについては、後続のセクションで説明します。

基本的なリスト操作

リストは＆plus;に応答しますおよび*文字列によく似た演算子。ここでも連結と繰り返しを意味しますが、結果は文字列ではなく新しいリストです。

実際、リストは、前の章で文字列に使用したすべての一般的なシーケンス操作に対応します。

Python Expression	Results	Description
len([1, 2, 3])	3	Length
[1, 2, 3] PLUS [4, 5, 6]	[1, 2, 3, 4, 5, 6]	Concatenation
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	Repetition
3 in [1, 2, 3]	True	Membership
for x in [1,2,3] : print (x,end = ' ')	1 2 3	Iteration

インデックス作成、スライス、およびマトリックス

リストはシーケンスであるため、インデックス付けとスライスは、リストに対しても文字列に対してと同じように機能します。

次の入力を想定-

L = ['C++'', 'Java', 'Python']

Python Expression	Results	Description
L[2]	'Python'	Offsets start at zero
L[-2]	'Java'	Negative: count from the right
L[1:]	['Java', 'Python']	Slicing fetches sections

組み込みのリスト関数とメソッド

Pythonには次のリスト関数が含まれています-

Sr.No.	Function & Description
1	cmp(list1, list2) Python 3では使用できなくなりました。
2	len(list) リストの全長を示します。
3	max(list) 最大値でリストからアイテムを返します。
4	min(list) 最小値を持つリストからアイテムを返します。
5	list(seq) タプルをリストに変換します。

Pythonには次のリストメソッドが含まれています-

Sr.No.	Methods & Description
1	list.append(obj) オブジェクトobjをリストに追加します
2	list.count(obj) リストにobjが出現する回数のカウントを返します
3	list.extend(seq) seqの内容をリストに追加します
4	list.index(obj) objが現れるリスト内の最低のインデックスを返します
5	list.insert(index, obj) オブジェクトobjをオフセットインデックスでリストに挿入します
6	list.pop(obj = list[-1)] リストから最後のオブジェクトまたはobjを削除して返します
7	list.remove(obj) リストからオブジェクトobjを削除します
8	list.reverse() リストのオブジェクトを所定の位置に反転します
9	list.sort([func)] リストのオブジェクトをソートし、指定されている場合は比較関数を使用します

Python 3-タプル

タプルは、不変のPythonオブジェクトのシーケンスです。 タプルはリストと同様にシーケンスです。 タプルとリストの主な違いは、リストとは異なり、タプルを変更できないことです。 タプルは括弧を使用しますが、リストは角括弧を使用します。

タプルの作成は、カンマで区切られた異なる値を入れるのと同じくらい簡単です。 オプションで、これらのコンマ区切り値を括弧で囲むこともできます。 たとえば-

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

空のタプルは、何も含まない2つの括弧として書かれています-

tup1 = ();

単一の値を含むタプルを書くには、値が1つしかない場合でもコンマを含める必要があります-

tup1 = (50,)

文字列インデックスと同様に、タプルインデックスは0から始まり、スライス、連結などが可能です。

タプルの値へのアクセス

タプルの値にアクセスするには、1つまたは複数のインデックスとともにスライスに角かっこを使用して、そのインデックスで使用可能な値を取得します。 たとえば-

#!/usr/bin/python3

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

上記のコードが実行されると、次の結果が生成されます-

tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

タプルの更新

タプルは不変です。つまり、タプル要素の値を更新または変更することはできません。 次の例に示すように、既存のタプルの一部を使用して新しいタプルを作成できます-

#!/usr/bin/python3

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# Following action is not valid for tuples
# tup1[0] = 100;

# So let's create a new tuple as follows
tup3 = tup1 + tup2
print (tup3)

上記のコードが実行されると、次の結果が生成されます-

(12, 34.56, 'abc', 'xyz')

タプル要素を削除する

個々のタプル要素を削除することはできません。 もちろん、不要な要素を破棄して別のタプルを作成しても何も問題はありません。

タプル全体を明示的に削除するには、 del ステートメントを使用します。 たとえば-

#!/usr/bin/python3

tup = ('physics', 'chemistry', 1997, 2000);

print (tup)
del tup;
print ("After deleting tup : ")
print (tup)

これにより、次の結果が生成されます。

注意-例外が発生します。 これは、 del tup の後、タプルがもう存在しないためです。

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
   File "test.py", line 9, in <module>
      print tup;
NameError: name 'tup' is not defined

基本的なタプル操作

タプルは＆plus;に応答しますおよび*文字列によく似た演算子。ここでも連結と繰り返しを意味しますが、結果は文字列ではなく新しいタプルです。

実際、タプルは、前の章で文字列に使用した一般的なシーケンス操作のすべてに応答します。

Python Expression	Results	Description
len1, 2, 31, 2, 3	3	Length
(1, 2, 3) PLUS (4, 5, 6)	(1, 2, 3, 4, 5, 6)	Concatenation
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	Repetition
3 in (1, 2, 3)	True	Membership
for x in (1,2,3) : print (x, end = ' ')	1 2 3	Iteration

インデックス付け、スライス、および行列

タプルはシーケンスであるため、インデックス付けとスライスは、次の入力を想定して、文字列の場合と同じようにタプルでも同じように機能します-

T=('C++', 'Java', 'Python')

Python Expression	Results	Description
T[2]	'Python'	Offsets start at zero
T[-2]	'Java'	Negative: count from the right
T[1:]	('Java', 'Python')	Slicing fetches sections

囲みデリミタなし

これらの短い例で示されているように、囲みデリミタは、カンマ区切りで識別記号なしで記述された複数のオブジェクトのセット、つまりリストの括弧、タプルの括弧などであり、デフォルトはタプルです。

組み込みタプル関数

Pythonには次のタプル関数が含まれています-

Sr.No.	Function & Description
1	cmp(tuple1, tuple2) 両方のタプルの要素を比較します。
2	len(tuple) タプルの全長を示します。
3	max(tuple) 最大値でタプルから項目を返します。
4	min(tuple) 最小値を持つタプルから項目を返します。
5	tuple(seq) リストをタプルに変換します。

Python 3-辞書

各キーはコロン（:)で値と区切られ、アイテムはコンマで区切られ、全体が中括弧で囲まれます。 アイテムのない空の辞書は、次のように中括弧2つだけで記述されます：\ {}。

キーは辞書内で一意ですが、値は一意ではありません。 ディクショナリの値はどのタイプでもかまいませんが、キーは文字列、数値、タプルなどの不変のデータタイプである必要があります。

辞書の値へのアクセス

辞書の要素にアクセスするには、おなじみの角括弧とキーを使用してその値を取得できます。 以下は簡単な例です-

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

上記のコードが実行されると、次の結果が生成されます-

dict['Name']:  Zara
dict['Age']:  7

辞書の一部ではないキーでデータ項目にアクセスしようとすると、次のようにエラーが発生します-

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print ("dict['Alice']: ", dict['Alice'])

上記のコードが実行されると、次の結果が生成されます-

dict['Zara']:
Traceback (most recent call last):
   File "test.py", line 4, in <module>
      print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'

辞書の更新

以下の簡単な例に示すように、新しいエントリまたはキーと値のペアを追加したり、既存のエントリを変更したり、既存のエントリを削除したりして、辞書を更新できます。

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School" # Add new entry

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

上記のコードが実行されると、次の結果が生成されます-

dict['Age']:  8
dict['School']:  DPS School

辞書要素を削除する

個々の辞書要素を削除するか、辞書の内容全体を消去できます。 1回の操作で辞書全体を削除することもできます。

辞書全体を明示的に削除するには、 del ステートメントを使用します。 以下は簡単な例です-

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

del dict['Name'] # remove entry with key 'Name'
dict.clear()     # remove all entries in dict
del dict         # delete entire dictionary

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

これにより、次の結果が生成されます。

*del dict* の後、辞書はもう存在しないため、例外が発生します。

dict['Age']:
Traceback (most recent call last):
   File "test.py", line 8, in <module>
      print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

注-del（）メソッドについては、後続のセクションで説明します。

辞書キーのプロパティ

辞書の値には制限がありません。 標準オブジェクトまたはユーザー定義オブジェクトの任意のPythonオブジェクトを使用できます。 ただし、キーについても同様ではありません。

辞書キーについて覚えておくべき2つの重要な点があります-

• （a）*キーごとに複数のエントリは許可されません。 これは、重複キーが許可されないことを意味します。 割り当て中に重複キーが検出されると、最後の割り当てが優先されます。 たとえば-

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print ("dict['Name']: ", dict['Name'])

上記のコードが実行されると、次の結果が生成されます-

dict['Name']:  Manni

• （b）*キーは不変でなければなりません。 つまり、文字列、数字、またはタプルを辞書キーとして使用できますが、['key']のようなものは許可されません。 以下は簡単な例です-

#!/usr/bin/python3

dict = {['Name']: 'Zara', 'Age': 7}
print ("dict['Name']: ", dict['Name'])

上記のコードが実行されると、次の結果が生成されます-

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      dict = {['Name']: 'Zara', 'Age': 7}
TypeError: list objects are unhashable

組み込みの辞書関数とメソッド

Pythonには次の辞書関数が含まれています-

Sr.No.	Function & Description
1	cmp(dict1, dict2) Python 3では使用できなくなりました。
2	len(dict) 辞書の全長を示します。 これは、ディクショナリ内のアイテムの数に等しくなります。
3	str(dict) 辞書の印刷可能な文字列表現を生成します
4	type(variable) 渡された変数の型を返します。 渡された変数が辞書の場合、辞書タイプを返します。

Pythonには次の辞書メソッドが含まれています-

Sr.No.	Method & Description
1	dict.clear() 辞書_dict_のすべての要素を削除します
2	dict.copy() 辞書_dict_の浅いコピーを返します
3	dict.fromkeys() seqのキーと値_set_から_value_で新しい辞書を作成します。
4	dict.get(key _key_キーの場合、キーが辞書にない場合は値またはデフォルトを返します
5	dict.has_key(key) 削除されました。代わりに_in_操作を使用してください。
6	dict.items() _dict_の（キー、値）タプルペアのリストを返します
7	dict.keys() 辞書辞書のキーのリストを返します
8	dict.setdefault(key get（）に似ていますが、_key_が既にdictにない場合はdict [key] = defaultを設定します
9	dict.update(dict2) 辞書_dict2_のキーと値のペアを_dict_に追加します
10	dict.values() 辞書_dict_の値のリストを返します

Python 3-日付と時刻

Pythonプログラムは、いくつかの方法で日付と時刻を処理できます。 日付形式間の変換は、コンピューターの一般的な雑用です。 Pythonの時間モジュールとカレンダーモジュールは、日付と時間の追跡に役立ちます。

ティックとは何ですか？

時間間隔は、秒単位の浮動小数点数です。 特定の瞬間は、1970年1月1日（エポック）の午前12時からの秒数で表されます。

Pythonで利用できる人気のある time モジュールがあり、これは時間を操作したり、表現間で変換するための機能を提供します。 関数* time.time（）*は、1970年1月1日（エポック）の午前12:00以降の現在のシステム時刻をティック単位で返します。

例

#!/usr/bin/python3
import time;      # This is required to include time module.

ticks = time.time()
print ("Number of ticks since 12:00am, January 1, 1970:", ticks)

これは次のような結果を生成します-

Number of ticks since 12:00am, January 1, 1970: 1455508609.34375

日付の算術はティックで簡単に行えます。 ただし、エポックより前の日付をこの形式で表すことはできません。 遠い将来の日付もこの方法で表すことはできません-カットオフポイントは、UNIXとWindowsの2038年のいつかです。

TimeTupleとは何ですか？

Pythonの時間関数の多くは、以下に示すように、9つの数字のタプルとして時間を処理します-

Index	Field	Values
0	4-digit year	2016
1	Month	1 to 12
2	Day	1 to 31
3	Hour	0 to 23
4	Minute	0 to 59
5	Second	0 to 61 (60 or 61 are leap-seconds)
6	Day of Week	0 to 6 (0 is Monday)
7	Day of year	1 to 366 (Julian day)
8	Daylight savings	-1, 0, 1, -1 means library determines DST

例-

import time

print (time.localtime());

これは次のような結果を生成します-

time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, tm_hour = 9,
   tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

上記のタプルは struct_time 構造体と同等です。 この構造には次の属性があります-

Index	Attributes	Values
0	tm_year	2016
1	tm_mon	1 to 12
2	tm_mday	1 to 31
3	tm_hour	0 to 23
4	tm_min	0 to 59
5	tm_sec	0 to 61 (60 or 61 are leap-seconds)
6	tm_wday	0 to 6 (0 is Monday)
7	tm_yday	1 to 366 (Julian day)
8	tm_isdst	-1, 0, 1, -1 means library determines DST

現在の時刻を取得する

エポックの浮動小数点値からの秒数から時刻をタイムタプルに変換するには、浮動小数点値を、有効な9項目すべてを含むタイムタプルを返す関数（たとえば、localtime）に渡します。

#!/usr/bin/python3
import time

localtime = time.localtime(time.time())
print ("Local current time :", localtime)

これは、他の提示可能な形式でフォーマットすることができる次の結果を生成します-

Local current time : time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15,
   tm_hour = 9, tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

フォーマットされた時間を取得する

要件に応じていつでもフォーマットできますが、読み取り可能な形式で時間を取得する簡単な方法は* asctime（）*です-

リンク：[]

#!/usr/bin/python3
import time

localtime = time.asctime( time.localtime(time.time()) )
print ("Local current time :", localtime)

これは、次の結果を生成します-

Local current time : Mon Feb 15 09:34:03 2016

1か月のカレンダーを取得する

カレンダーモジュールは、毎年および毎月のカレンダーで遊ぶための幅広い方法を提供します。 ここでは、特定の月（2008年1月）のカレンダーを印刷します-

#!/usr/bin/python3
import calendar

cal = calendar.month(2016, 2)
print ("Here is the calendar:")
print (cal)

これは、次の結果を生成します-

Here is the calendar:
   February 2016
Mo Tu We Th Fr Sa Su
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29

時間モジュール

Pythonで利用できる人気のある time モジュールがあります。これは、時間を操作したり、表現間で変換したりするための関数を提供します。 利用可能なすべてのメソッドのリストを以下に示します。

Sr.No.	Function & Description
1	time.altzone UTCの西の秒単位のローカルDSTタイムゾーンのオフセット（定義されている場合）。 これは、ローカルDSTタイムゾーンがUTCの東にある場合は負です（英国を含む西ヨーロッパの場合）。 日光がゼロ以外の場合に使用します。
2	time.asctime([tupletime)] タイムタプルを受け入れ、「Tue Dec 11 18:07:14 2008」などの読み取り可能な24文字の文字列を返します。
3	time.clock( ) 現在のCPU時間を浮動小数点数として返します。 さまざまなアプローチの計算コストを測定するには、time.clockの値がtime.time（）の値よりも有用です。
4	time.ctime([secs)] asctime（localtime（secs））のように、引数なしはasctime（）のようになります
5	time.gmtime([secs)] エポックからの秒数で表されるインスタントを受け入れ、UTC時間を含むタイムタプルtを返します。 注-t.tm_isdstは常に0です
6	time.localtime([secs)] エポックからの秒数で表されるインスタントを受け入れ、ローカル時間のタイムタプルtを返します（ローカルルールによってDSTがインスタントsecsに適用されるかどうかに応じて、t.tm_isdstは0または1です）。
7	time.mktime(tupletime) ローカル時間のタイムタプルとして表されるインスタントを受け入れ、エポックからの秒数で表されるインスタントを含む浮動小数点値を返します。
8	time.sleep(secs) 呼び出しスレッドをsecs秒間中断します。
9	time.strftime(fmt[,tupletime)] 現地時間のタイムタプルとして表されるインスタントを受け入れ、文字列fmtで指定されたインスタントを表す文字列を返します。
10	time.strptime(str フォーマット文字列fmtに従ってstrを解析し、インスタントをタイムタプル形式で返します。
11	time.time( ) 現在の時刻、エポックからの秒数の浮動小数点数を返します。
12	time.tzset() ライブラリルーチンで使用される時間変換ルールをリセットします。 環境変数TZは、これを行う方法を指定します。

タイムモジュールでは、2つの重要な属性を使用できます。 彼らは-

Sr.No.	Attribute & Description
1	time.timezone 属性time.timezoneは、UTCからのローカルタイムゾーン（DSTなし）の秒単位のオフセットです（アメリカ大陸では0、ヨーロッパ、アジア、アフリカのほとんどでは⇐ 0）。
2	time.tzname 属性time.tznameは、ロケールに依存する文字列のペアです。これらは、それぞれDSTを使用する場合と使用しない場合のローカルタイムゾーンの名前です。

カレンダーモジュール

カレンダーモジュールは、特定の月または年のテキストカレンダーを印刷する機能を含む、カレンダー関連の機能を提供します。

デフォルトでは、カレンダーは月曜日を週の最初の日とし、日曜日を最後の日とします。 これを変更するには、* calendar.setfirstweekday（）*関数を呼び出します。

*calendar* モジュールで利用可能な機能のリストは次のとおりです-

Sr.No.	Function & Description
1	calendar.calendar(year,w = 2,l = 1,c = 6) cスペースで区切られた3つの列にフォーマットされた年yearのカレンダーを含む複数行の文字列を返します。 wは各日付の文字の幅です。各行の長さは21 w＆plus; 18＆plus; 2 cです。 lは、各週の行数です。
2	calendar.firstweekday( ) 毎週始まる平日の現在の設定を返します。 デフォルトでは、カレンダーが最初にインポートされるとき、これは月曜日を意味する0です。
3	calendar.isleap(year) 年がうるう年の場合Trueを返します。それ以外の場合、False。
4	calendar.leapdays(y1,y2) range（y1、y2）内の年のうるう日の合計数を返します。
5	calendar.month(year,month,w = 2,l = 1) 年、年、月、月、1週に1行、2行のヘッダー行のカレンダーを含む複数行の文字列を返します。 wは各日付の文字の幅です。各行の長さは7 *w＆plus; 6です。 lは、各週の行数です。
6	calendar.monthcalendar(year,month)* intのリストのリストを返します。 各サブリストは週を示します。 年の月の月以外の日は0に設定されます。月内の日は、その月の1日以上に設定されます。
7	calendar.monthrange(year,month) 2つの整数を返します。 最初のものは、年yearの月monthの最初の日の平日のコードです。 2番目は月の日数です。 曜日コードは0（月曜日）〜6（日曜日）です。月の番号は1〜12です。
8	calendar.prcal(year,w = 2,l = 1,c = 6) 印刷calendar.calendar（year、w、l、c）のように。
9	calendar.prmonth(year,month,w = 2,l = 1) print calendar.month（year、month、w、l）のように。
10	calendar.setfirstweekday(weekday) 週の最初の日を平日コードに設定します。 曜日コードは0（月曜日）から6（日曜日）です。
11	calendar.timegm(tupletime) time.gmtimeの逆：タイムタプル形式の時刻を受け取り、エポック以降の浮動小数点数と同じ瞬間を返します。
12	calendar.weekday(year,month,day) 指定された日付の曜日コードを返します。 曜日コードは0（月曜日）〜6（日曜日）です。月番号は1（1月）から12（12月）です。

その他のモジュールと機能

興味がある場合は、ここで、Pythonで日付と時刻を操作する他の重要なモジュールと関数のリストを見つけます-

• The datetime Module
• The pytz Module
• dateutilモジュール

Python 3-関数

関数は、単一の関連アクションを実行するために使用される、整理された再利用可能なコードのブロックです。 関数を使用すると、アプリケーションのモジュール性が向上し、高度なコードの再利用が可能になります。

既にご存じのとおり、Pythonにはprint（）などの多くの組み込み関数が用意されています。 ただし、独自の関数を作成することもできます。 これらの関数は_user-defined functions._と呼ばれます。

関数を定義する

関数を定義して、必要な機能を提供できます。 Pythonで関数を定義する簡単なルールを次に示します。

• 関数ブロックは、キーワード def で始まり、その後に関数名と括弧（（））が続きます。
• 入力パラメータまたは引数は、これらの括弧内に配置する必要があります。 これらの括弧内にパラメーターを定義することもできます。
• 関数の最初のステートメントは、オプションのステートメント（関数のドキュメント文字列または_docstring_）にすることができます。
• すべての関数内のコードブロックはコロン（:)で始まり、インデントされます。
• ステートメントreturn [expression]は関数を終了し、オプションで式を呼び出し元に返します。 引数なしのreturnステートメントは、return Noneと同じです。

構文

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

デフォルトでは、パラメーターには定位置動作があり、定義されたのと同じ順序で通知する必要があります。

例

次の関数は、入力パラメーターとして文字列を受け取り、標準画面に出力します。

def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

関数を呼び出す

関数を定義すると、関数に名前が付けられ、関数に含まれるパラメーターが指定され、コードのブロックが構成されます。

関数の基本構造が完成したら、別の関数から呼び出すか、Pythonプロンプトから直接呼び出して実行できます。 以下は、* printme（）*関数を呼び出す例です-

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme("This is first call to the user defined function!")
printme("Again second call to the same function")

上記のコードが実行されると、次の結果が生成されます-

This is first call to the user defined function!
Again second call to the same function

参照渡しと値渡し

Python言語のすべてのパラメーター（引数）は参照によって渡されます。 関数内でパラメータが参照するものを変更すると、その変更は呼び出し元の関数にも反映されます。 たとえば-

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("Values inside the function before change: ", mylist)

   mylist[2]=50
   print ("Values inside the function after change: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

ここでは、渡されたオブジェクトの参照を維持し、同じオブジェクトに値を追加しています。 したがって、これは次の結果を生成します-

Values inside the function before change:  [10, 20, 30]
Values inside the function after change:  [10, 20, 50]
Values outside the function:  [10, 20, 50]

引数が参照によって渡され、参照が呼び出された関数内で上書きされるもう1つの例があります。

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4] # This would assi new reference in mylist
   print ("Values inside the function: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

パラメーター mylist は、関数changemeに対してローカルです。 関数内でmylistを変更しても、mylistには影響しません。 関数は何も達成せず、最終的にこれは次の結果を生成します-

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

関数の引数

次のタイプの仮引数を使用して関数を呼び出すことができます-

• 必須の引数
• キーワード引数
• デフォルト引数
• 可変長引数

必須の引数

必須の引数は、正しい位置の順序で関数に渡される引数です。 ここで、関数呼び出しの引数の数は、関数定義と正確に一致する必要があります。

関数* printme（）*を呼び出すには、必ず1つの引数を渡す必要があります。そうしないと、次のように構文エラーが発生します-

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme()

上記のコードが実行されると、次の結果が生成されます-

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

キーワード引数

キーワード引数は、関数呼び出しに関連しています。 関数呼び出しでキーワード引数を使用する場合、呼び出し元はパラメーター名で引数を識別します。

これにより、Pythonインタープリターは提供されたキーワードを使用して値をパラメーターと一致させることができるため、引数をスキップしたり、順序を乱したりできます。 また、次の方法で* printme（）*関数へのキーワード呼び出しを行うことができます-

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme( str = "My string")

上記のコードが実行されると、次の結果が生成されます-

My string

次の例は、より明確な図を示しています。 パラメーターの順序は重要ではないことに注意してください。

#!/usr/bin/python3

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print ("Name: ", name)
   print ("Age ", age)
   return

# Now you can call printinfo function
printinfo( age = 50, name = "miki" )

上記のコードが実行されると、次の結果が生成されます-

Name:  miki
Age  50

デフォルトの引数

デフォルト引数は、その引数の関数呼び出しで値が提供されない場合にデフォルト値を想定する引数です。 次の例は、デフォルトの引数のアイデアを与え、それが渡されない場合、デフォルトの年齢を出力します-

#!/usr/bin/python3

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print ("Name: ", name)
   print ("Age ", age)
   return

# Now you can call printinfo function
printinfo( age = 50, name = "miki" )
printinfo( name = "miki" )

上記のコードが実行されると、次の結果が生成されます-

Name:  miki
Age  50
Name:  miki
Age  35

可変長引数

関数の定義中に指定したよりも多くの引数の関数を処理する必要がある場合があります。 これらの引数は_variable-length_引数と呼ばれ、必須およびデフォルトの引数とは異なり、関数定義では名前が付けられていません。

非キーワード変数引数を持つ関数の構文は次のとおりです-

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

すべての非キーワード変数引数の値を保持する変数名の前にアスタリスク（*）が置かれます。 関数呼び出し中に追加の引数が指定されていない場合、このタプルは空のままです。 以下は簡単な例です-

#!/usr/bin/python3

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print ("Output is: ")
   print (arg1)

   for var in vartuple:
      print (var)
   return

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

上記のコードが実行されると、次の結果が生成されます-

Output is:
10
Output is:
70
60
50

無名関数

これらの関数は、 def キーワードを使用して標準的な方法で宣言されていないため、匿名と呼ばれます。 lambda キーワードを使用して、小さな匿名関数を作成できます。

• Lambdaフォームは任意の数の引数を取ることができますが、式の形式で1つの値のみを返します。 コマンドや複数の式を含めることはできません。
• ラムダには式が必要なので、匿名関数を直接printに呼び出すことはできません。
• Lambda関数には独自のローカル名前空間があり、パラメーターリスト内の変数とグローバル名前空間内の変数以外の変数にはアクセスできません。
• ラムダは関数の1行バージョンのように見えますが、パフォーマンス上の理由で呼び出し中に関数を渡すことでスタックを割り当てることを目的とするCまたはC ++のインラインステートメントとは異なります。

構文

• ラムダ関数の構文には、次のような単一のステートメントのみが含まれています-

lambda [arg1 [,arg2,.....argn]]:expression

以下は、関数の lambda 形式がどのように機能するかを示す例です-

#!/usr/bin/python3

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2

# Now you can call sum as a function
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))

上記のコードが実行されると、次の結果が生成されます-

Value of total :  30
Value of total :  40

returnステートメント

ステートメントreturn [expression]は関数を終了し、オプションで式を呼び出し元に返します。 引数なしのreturnステートメントは、return Noneと同じです。

以下に示す例はすべて、値を返していません。 次のように関数から値を返すことができます-

#!/usr/bin/python3

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print ("Inside the function : ", total)
   return total

# Now you can call sum function
total = sum( 10, 20 )
print ("Outside the function : ", total )

上記のコードが実行されると、次の結果が生成されます-

Inside the function :  30
Outside the function :  30

変数の範囲

プログラム内のすべての変数は、そのプログラム内のすべての場所でアクセスできるわけではありません。 これは、変数を宣言した場所によって異なります。

変数のスコープは、特定の識別子にアクセスできるプログラムの部分を決定します。 Pythonには変数の2つの基本的なスコープがあります-

• グローバル変数
• ローカル変数

グローバルvs. ローカル変数

関数本体内で定義された変数はローカルスコープを持ち、外部で定義された変数はグローバルスコープを持ちます。

つまり、ローカル変数は宣言された関数内でのみアクセスできますが、グローバル変数はすべての関数によってプログラム本体全体でアクセスできます。 関数を呼び出すと、その中で宣言された変数がスコープに取り込まれます。 以下は簡単な例です-

#!/usr/bin/python3

total = 0   # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print ("Inside the function local total : ", total)
   return total

# Now you can call sum function
sum( 10, 20 )
print ("Outside the function global total : ", total )

上記のコードが実行されると、次の結果が生成されます-

Inside the function local total :  30
Outside the function global total :  0

Python 3-モジュール

モジュールを使用すると、Pythonコードを論理的に整理できます。 関連するコードをモジュールにグループ化すると、コードの理解と使用が容易になります。 モジュールは、バインドおよび参照できる任意の名前の属性を持つPythonオブジェクトです。

簡単に言えば、モジュールはPythonコードで構成されるファイルです。 モジュールは、関数、クラス、変数を定義できます。 モジュールには、実行可能なコードを含めることもできます。

例

anameという名前のモジュールのPythonコードは通常、aname.pyという名前のファイルにあります。 これは、単純なモジュール、support.pyの例です-

def print_func( par ):
   print "Hello : ", par
   return

インポートステートメント

他のPythonソースファイルでimportステートメントを実行することにより、任意のPythonソースファイルをモジュールとして使用できます。 *インポート*には次の構文があります-

import module1[, module2[,... moduleN]

インタープリターがimportステートメントを検出すると、モジュールが検索パスに存在する場合、モジュールをインポートします。 検索パスは、モジュールをインポートする前にインタープリターが検索するディレクトリーのリストです。 たとえば、モジュールhello.pyをインポートするには、スクリプトの先頭に次のコマンドを配置する必要があります-

#!/usr/bin/python3

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Zara")

上記のコードが実行されると、次の結果が生成されます-

Hello : Zara

モジュールは、インポートされた回数に関係なく、一度だけロードされます。 これにより、複数のインポートが発生した場合に、モジュールの実行が繰り返し発生するのを防ぎます。

from …​ importステートメント

Pythonの from ステートメントを使用すると、特定の属性をモジュールから現在のネームスペースにインポートできます。 from …​ import の構文は次のとおりです-

from modname import name1[, name2[, ... nameN]]

たとえば、モジュールfibから関数fibonacciをインポートするには、次のステートメントを使用します-

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

このステートメントは、モジュールfib全体を現在のネームスペースにインポートしません。モジュールfibから項目fibonacciをインポートモジュールのグローバルシンボルテーブルに導入するだけです。

from …​ import *ステートメント

また、次のインポートステートメントを使用して、モジュールから現在のネームスペースにすべての名前をインポートすることも可能です-

from modname import *

これにより、モジュールのすべてのアイテムを現在のネームスペースに簡単にインポートできます。ただし、このステートメントは慎重に使用する必要があります。

モジュールをスクリプトとして実行する

モジュール内では、モジュール名（文字列として）がグローバル変数nameの値として利用可能です。 モジュールのコードは、インポートした場合と同じように実行されますが、nameが "main"に設定されます。

あなたのモジュールの最後にこのコードを追加します-

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
if __name__ == "__main__":
   f = fib(100)
   print(f)

上記のコードを実行すると、次の出力が表示されます。

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

モジュールの特定

あなたがモジュールをインポートすると、Pythonインタープリターは次のシーケンスでモジュールを検索します-

• 現在のディレクトリ
• モジュールが見つからない場合、Pythonはシェル変数PYTHONPATHで各ディレクトリを検索します。
• 他のすべてが失敗した場合、Pythonはデフォルトパスをチェックします。 UNIXでは、このデフォルトパスは通常/usr/local/lib/python3/です。

モジュール検索パスは、システムモジュールsysに sys.path 変数として保存されます。 sys.path変数には、現在のディレクトリ、PYTHONPATH、およびインストールに依存するデフォルトが含まれます。

PYTHONPATH変数

PYTHONPATHは、ディレクトリのリストで構成される環境変数です。 PYTHONPATHの構文は、シェル変数PATHの構文と同じです。

これは、Windowsシステムからの典型的なPYTHONPATHです-

set PYTHONPATH = c:\python34\lib;

そして、ここにUNIXシステムからの典型的なPYTHONPATHがあります-

set PYTHONPATH =/usr/local/lib/python

名前空間とスコープ

変数は、オブジェクトにマップする名前（識別子）です。 _namespace_は、変数名（キー）とそれに対応するオブジェクト（値）の辞書です。

• Pythonステートメントは、_local namespace_および_global namespace_の変数にアクセスできます。 ローカル変数とグローバル変数の名前が同じ場合、ローカル変数はグローバル変数を隠します。
• 各関数には独自のローカル名前空間があります。 クラスメソッドは、通常の関数と同じスコープ規則に従います。
• Pythonは、変数がローカルであるかグローバルであるかについて知識に基づいた推測を行います。 関数内で値を割り当てられた変数はすべてローカルであると想定しています。
• したがって、関数内のグローバル変数に値を割り当てるには、最初にグローバルステートメントを使用する必要があります。
• ステートメント_global VarName_は、VarNameがグローバル変数であることをPythonに伝えます。 Pythonは変数のローカル名前空間の検索を停止します。

たとえば、グローバル名前空間で変数_Money_を定義します。 関数Money内で、Moneyに値を割り当てるため、PythonはMoneyをローカル変数と見なします。

ただし、設定する前にローカル変数_Money_の値にアクセスしたため、UnboundLocalErrorが結果になります。 グローバルステートメントのコメントを外すと、問題が修正されます。

#!/usr/bin/python3

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print (Money)
AddMoney()
print (Money)

dir（）関数

dir（）組み込み関数は、モジュールによって定義された名前を含むストリングのソート済みリストを返します。

リストには、モジュールで定義されているすべてのモジュール、変数、および関数の名前が含まれています。 以下は簡単な例です-

#!/usr/bin/python3

# Import built-in module math
import math

content = dir(math)
print (content)

上記のコードが実行されると、次の結果が生成されます-

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp',
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',
'sqrt', 'tan', 'tanh']

ここで、特別な文字列変数nameはモジュールの名前であり、fileはモジュールのロード元のファイル名です。

globals（）およびlocals（）関数

• globals（）および locals（）*関数を使用すると、呼び出し元の場所に応じて、グローバルおよびローカル名前空間の名前を返すことができます。
• * locals（）*が関数内から呼び出された場合、その関数からローカルにアクセスできるすべての名前が返されます。
• * globals（）*が関数内から呼び出された場合、その関数からグローバルにアクセスできるすべての名前が返されます。

これら両方の関数の戻り値の型は辞書です。 したがって、* keys（）*関数を使用して名前を抽出できます。

reload（）関数

モジュールをスクリプトにインポートすると、モジュールの最上位部分のコードは1回だけ実行されます。

したがって、モジュールの最上位コードを再実行する場合は、_reload（）_関数を使用できます。 reload（）関数は、以前にインポートされたモジュールを再度インポートします。 reload（）関数の構文はこれです-

reload(module_name)

ここで、module_nameはリロードするモジュールの名前であり、モジュール名を含む文字列ではありません。 たとえば、helloモジュールをリロードするには、次のようにします-

reload(hello)

Pythonのパッケージ

パッケージは、モジュール、サブパッケージ、サブサブパッケージなどで構成される単一のPythonアプリケーション環境を定義する階層ファイルディレクトリ構造です。

Phoneディレクトリにある_Pots.py_ファイルを考えてみましょう。 このファイルには、ソースコードの次の行があります-

#!/usr/bin/python3

def Pots():
print ("I'm Pots Phone")

同様に、上記と同じ名前の異なる機能を持つ他の2つのファイルがあります。 彼らは-

• _Phone/Isdn.py_関数Isdn（）を持つファイル
• 関数G3（）を持つ_Phone/G3.py_ファイル

今、_Phone_ディレクトリにもう1つのファイルinit.pyを作成します-

• Phone/init.py

Phoneをインポートしたときにすべての関数を使用できるようにするには、次のようにinit.pyに明示的なimportステートメントを配置する必要があります-

from Pots import Pots
from Isdn import Isdn
from G3 import G3

これらの行をinit.pyに追加すると、Phoneパッケージをインポートするときにこれらのクラスがすべて使用可能になります。

#!/usr/bin/python3

# Now import your Phone Package.
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

上記のコードが実行されると、次の結果が生成されます-

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

上記の例では、各ファイルに1つの関数の例を取り上げましたが、ファイルに複数の関数を保持できます。 また、これらのファイルにさまざまなPythonクラスを定義し、それらのクラスからパッケージを作成することもできます。

Python 3-ファイルI/O

この章では、Python 3で利用可能なすべての基本的なI/O関数について説明します。 その他の機能については、標準のPythonドキュメントを参照してください。

画面への印刷

出力を生成する最も簡単な方法は、_print_ステートメントを使用することです。このステートメントでは、0個以上の式をコンマで区切って渡すことができます。 この関数は、文字列に渡す式を変換し、次のように結果を標準出力に書き込みます-

#!/usr/bin/python3

print ("Python is really a great language,", "isn't it?")

これにより、標準画面に次の結果が生成されます-

Python is really a great language, isn't it?

キーボード入力の読み取り

Python 2には、標準入力からデータを読み取るための2つの組み込み関数があり、デフォルトではキーボードから取得されます。 これらの関数は* input（）および raw_input（）*です

Python 3では、raw_input（）関数は非推奨です。 さらに、input（）関数は、引用符（ または ""）で囲まれているかどうかに関係なく、キーボードからデータを文字列として読み取ります。

入力関数

• input（[prompt]）*関数は、入力が有効なPython式であると想定し、評価結果を返すことを除き、raw_inputと同等です。

#!/usr/bin/python3

>>> x = input("something:")
something:10

>>> x
'10'

>>> x = input("something:")
something:'10' #entered data treated as string with or without ''

>>> x
"'10'"

ファイルの開閉

これまで、標準入出力の読み取りと書き込みを行ってきました。 次に、実際のデータファイルの使用方法について説明します。

Pythonは、デフォルトでファイルを操作するために必要な基本的な関数とメソッドを提供します。 file オブジェクトを使用して、ほとんどのファイル操作を行うことができます。

オープン関数

ファイルを読み書きする前に、Pythonの組み込みopen（）関数を使用してファイルを開く必要があります。 この関数は、関連する他のサポートメソッドを呼び出すために利用される file オブジェクトを作成します。

構文

file object = open(file_name [, access_mode][, buffering])

ここにパラメータの詳細があります-

• file_name -file_name引数は、アクセスするファイルの名前を含む文字列値です。
• access_mode -access_modeは、ファイルを開く必要があるモード、つまり読み取り、書き込み、追加などを決定します。 可能な値の完全なリストを以下の表に示します。 これはオプションのパラメーターであり、デフォルトのファイルアクセスモードは読み取り（r）です。
• バッファリング-バッファリング値が0に設定されている場合、バッファリングは行われません。 バッファリング値が1の場合、ファイルへのアクセス中に行バッファリングが実行されます。 バッファリング値を1より大きい整数として指定すると、指定されたバッファサイズでバッファリングアクションが実行されます。 負の場合、バッファサイズはシステムのデフォルトです（デフォルトの動作）。

ここにファイルを開くさまざまなモードのリストがあります-

Sr.No.	Mode & Description
1	r 読み取り専用でファイルを開きます。 ファイルポインタはファイルの先頭に置かれます。 これがデフォルトのモードです。
2	rb バイナリ形式でのみ読み取り用にファイルを開きます。 ファイルポインタはファイルの先頭に置かれます。 これがデフォルトのモードです。
3	rPLUS 読み取りと書き込みの両方のためにファイルを開きます。 ファイルの先頭に配置されたファイルポインター。
4	rbPLUS 読み取りと書き込みの両方のファイルをバイナリ形式で開きます。 ファイルの先頭に配置されたファイルポインター。
5	w 書き込み専用にファイルを開きます。 ファイルが存在する場合はファイルを上書きします。 ファイルが存在しない場合は、書き込み用の新しいファイルを作成します。
6	wb バイナリ形式でのみ書き込み用にファイルを開きます。 ファイルが存在する場合はファイルを上書きします。 ファイルが存在しない場合は、書き込み用の新しいファイルを作成します。
7	wPLUS 書き込みと読み取りの両方のためにファイルを開きます。 ファイルが存在する場合、既存のファイルを上書きします。 ファイルが存在しない場合、読み取りおよび書き込み用の新しいファイルを作成します。
8	wbPLUS 書き込みと読み取りの両方のファイルをバイナリ形式で開きます。 ファイルが存在する場合、既存のファイルを上書きします。 ファイルが存在しない場合、読み取りおよび書き込み用の新しいファイルを作成します。
9	a 追加するファイルを開きます。 ファイルが存在する場合、ファイルポインタはファイルの末尾にあります。 つまり、ファイルは追加モードになっています。 ファイルが存在しない場合は、書き込み用の新しいファイルを作成します。
10	ab バイナリ形式で追加するためのファイルを開きます。 ファイルが存在する場合、ファイルポインタはファイルの末尾にあります。 つまり、ファイルは追加モードになっています。 ファイルが存在しない場合は、書き込み用の新しいファイルを作成します。
11	aPLUS 追加と読み取りの両方のためにファイルを開きます。 ファイルが存在する場合、ファイルポインタはファイルの末尾にあります。 ファイルが追加モードで開きます。 ファイルが存在しない場合、読み取りおよび書き込み用の新しいファイルが作成されます。
12	abPLUS バイナリ形式で追加と読み取りの両方のためにファイルを開きます。 ファイルが存在する場合、ファイルポインタはファイルの末尾にあります。 ファイルが追加モードで開きます。 ファイルが存在しない場合、読み取りおよび書き込み用の新しいファイルが作成されます。

ファイルのオブジェクト属性

ファイルを開いて_file_オブジェクトを1つ作成すると、そのファイルに関連するさまざまな情報を取得できます。

これは、ファイルオブジェクトに関連するすべての属性のリストです-

Sr.No.	Attribute & Description
1	file.closed ファイルが閉じている場合はtrue、そうでない場合はfalseを返します。
2	file.mode ファイルを開いたときのアクセスモードを返します。
3	file.name ファイルの名前を返します。

注意-ソフトスペース属性はPython 3.xではサポートされていません

例

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)
print ("Closed or not : ", fo.closed)
print ("Opening mode : ", fo.mode)
fo.close()

これは、次の結果を生成します-

Name of the file:  foo.txt
Closed or not :  False
Opening mode :  wb

close（）メソッド

ファイルオブジェクトのclose（）メソッドは、書き込まれていない情報をフラッシュし、ファイルオブジェクトを閉じます。その後、書き込みはできなくなります。

Pythonは、ファイルの参照オブジェクトが別のファイルに再割り当てされると、ファイルを自動的に閉じます。 close（）メソッドを使用してファイルを閉じることをお勧めします。

構文

fileObject.close();

例

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)

# Close opened file
fo.close()

これは、次の結果を生成します-

Name of the file:  foo.txt

ファイルの読み書き

ファイルオブジェクトは、私たちの生活を楽にする一連のアクセス方法を提供します。 * read（）および write（）*メソッドを使用してファイルを読み書きする方法がわかります。

write（）メソッド

• write（）*メソッドは、任意の文字列を開いているファイルに書き込みます。 Python文字列には、テキストだけでなくバイナリデータを含めることができることに注意することが重要です。

write（）メソッドは、文字列の末尾に改行文字（ '\ n'）を追加しません-

構文

fileObject.write(string);

ここで、渡されるパラメーターは、開かれたファイルに書き込まれるコンテンツです。

例

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "w")
fo.write( "Python is a great language.\nYeah its great!!\n")

# Close opend file
fo.close()

上記のメソッドはfoo.txtファイルを作成し、指定されたコンテンツをそのファイルに書き込み、最後にそのファイルを閉じます。 このファイルを開く場合、次の内容があります-

Python is a great language.
Yeah its great!!

read（）メソッド

• read（）*メソッドは、開いているファイルから文字列を読み取ります。 Python文字列にはバイナリデータを含めることができることに注意することが重要です。 テキストデータは別として。

構文

fileObject.read([count]);

ここで、渡されたパラメーターは、開かれたファイルから読み取られるバイト数です。 このメソッドは、ファイルの先頭から読み取りを開始し、_count_が欠落している場合、可能な限り、おそらくファイルの終わりまで読み取りを試みます。

例

上記で作成したファイル_foo.txt_を使用してみましょう。

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print ("Read String is : ", str)

# Close opened file
fo.close()

これは、次の結果を生成します-

Read String is :  Python is

ファイルの位置

_tell（）_メソッドは、ファイル内の現在の位置を示します。つまり、次の読み取りまたは書き込みは、ファイルの先頭からそのバイト数で発生します。

_seek（offset [、from]）_メソッドは、現在のファイルの位置を変更します。 offset 引数は、移動するバイト数を示します。 from 引数は、バイトの移動元の参照位置を指定します。

_from_が0に設定されている場合、ファイルの先頭が参照位置として使用されます。 1に設定されている場合、現在の位置が基準位置として使用されます。 2に設定されている場合、ファイルの末尾が参照位置として使用されます。

例

上記で作成したファイル_foo.txt_を使用してみましょう。

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print ("Read String is : ", str)

# Check current position
position = fo.tell()
print ("Current file position : ", position)

# Reposition pointer at the beginning once again
position = fo.seek(0, 0)
str = fo.read(10)
print ("Again read String is : ", str)

# Close opened file
fo.close()

これは、次の結果を生成します-

Read String is :  Python is
Current file position :  10
Again read String is :  Python is

ファイルの名前変更と削除

Python os モジュールは、ファイルの名前変更や削除などのファイル処理操作の実行に役立つメソッドを提供します。

このモジュールを使用するには、最初にインポートする必要があります。その後、関連する関数を呼び出すことができます。

rename（）メソッド

• rename（）*メソッドは、現在のファイル名と新しいファイル名の2つの引数を取ります。

構文

os.rename(current_file_name, new_file_name)

例

以下は、既存のファイル_test1.txt_の名前を変更する例です-

#!/usr/bin/python3
import os

# Rename a file from test1.txt to test2.txt
os.rename( "test1.txt", "test2.txt" )

remove（）メソッド

• remove（）*メソッドを使用して、削除するファイルの名前を引数として指定することにより、ファイルを削除できます。

構文

os.remove(file_name)

例

以下は、既存のファイル_test2.txt_を削除する例です-

#!/usr/bin/python3
import os

# Delete file test2.txt
os.remove("text2.txt")

Pythonのディレクトリ

すべてのファイルはさまざまなディレクトリに含まれており、Pythonでもこれらの処理に問題はありません。 os モジュールには、ディレクトリの作成、削除、変更に役立ついくつかのメソッドがあります。

mkdir（）メソッド

*os* モジュールの* mkdir（）*メソッドを使用して、現在のディレクトリにディレクトリを作成できます。 作成するディレクトリの名前を含むこのメソッドに引数を指定する必要があります。

構文

os.mkdir("newdir")

例

以下は、現在のディレクトリにディレクトリ_test_を作成する例です-

#!/usr/bin/python3
import os

# Create a directory "test"
os.mkdir("test")

chdir（）メソッド

_chdir（）_メソッドを使用して、現在のディレクトリを変更できます。 chdir（）メソッドは引数を取ります。これは、現在のディレクトリにしたいディレクトリの名前です。

構文

os.chdir("newdir")

例

以下は、「/home/newdir」ディレクトリに移動する例です-

#!/usr/bin/python3
import os

# Changing a directory to "/home/newdir"
os.chdir("/home/newdir")

getcwd（）メソッド

• getcwd（）*メソッドは、現在の作業ディレクトリを表示します。

構文

os.getcwd()

例

以下は、現在のディレクトリを与えるための例です-

#!/usr/bin/python3
import os

# This would give location of the current directory
os.getcwd()

rmdir（）メソッド

• rmdir（）*メソッドは、メソッド内の引数として渡されるディレクトリを削除します。

ディレクトリを削除する前に、その中のすべてのコンテンツを削除する必要があります。

構文

os.rmdir('dirname')

例

以下は、「/tmp/test」ディレクトリを削除する例です。 ディレクトリの完全修飾名を指定する必要があります。指定しない場合、現在のディレクトリでそのディレクトリを検索します。

#!/usr/bin/python3
import os

# This would  remove "/tmp/test"  directory.
os.rmdir( "/tmp/test"  )

ファイルおよびディレクトリ関連のメソッド

3つの重要なソースがあり、WindowsおよびUnixオペレーティングシステムでファイルとディレクトリを処理および操作するための幅広いユーティリティメソッドを提供しています。 彼らは次のとおりです-

 *リンク：/python3/file_methods [ファイルオブジェクトメソッド]
+* file *オブジェクトは、ファイルを操作する関数を提供します。
* リンク：/python3/os_file_methods [OSオブジェクトメソッド]
+これは、ファイルとディレクトリを処理するメソッドを提供します。

Python 3-例外処理

Pythonは、Pythonプログラムの予期しないエラーを処理し、デバッグ機能を追加するための2つの非常に重要な機能を提供します-

• 例外処理-これについては、このチュートリアルで説明します。 Pythonで利用可能な標準の例外のリストを次に示します-link：/python3/python_exceptions＃standard_exceptions [Standard Exceptions]。
• アサーション-これはlink：/python3/python_exceptions＃assertion_python [Assertions in Python 3]チュートリアルでカバーされます。

標準的な例外

Pythonで利用可能な標準例外のリストを以下に示します。 −

Sr.No.	Exception Name & Description
1	Exception すべての例外の基本クラス
2	StopIteration イテレータのnext（）メソッドがオブジェクトを指さない場合に発生します。
3	SystemExit sys.exit（）関数によって発生します。
4	StandardError StopIterationおよびSystemExitを除くすべての組み込み例外の基本クラス。
5	ArithmeticError 数値計算で発生するすべてのエラーの基本クラス。
6	OverflowError 計算が数値型の上限を超えたときに発生します。
7	FloatingPointError 浮動小数点計算が失敗したときに発生します。
8	ZeroDivisonError すべての数値型でゼロによる除算またはモジュロが行われるときに発生します。
9	AssertionError Assertステートメントが失敗した場合に発生します。
10	AttributeError 属性の参照または割り当てが失敗した場合に発生します。
11	EOFError raw_input（）またはinput（）関数からの入力がなく、ファイルの終わりに達したときに発生します。
12	ImportError インポート文が失敗したときに発生します。
13	KeyboardInterrupt 通常Ctrl + cを押すことにより、ユーザーがプログラムの実行を中断したときに発生します。
14	LookupError すべてのルックアップエラーの基本クラス。
15	IndexError シーケンス内でインデックスが見つからない場合に発生します。
16	KeyError 指定されたキーが辞書に見つからない場合に発生します。
17	NameError ローカルまたはグローバル名前空間に識別子が見つからない場合に発生します。
18	UnboundLocalError 関数またはメソッドのローカル変数にアクセスしようとしたが、値が割り当てられていないときに発生します。
19	EnvironmentError Python環境外で発生するすべての例外の基本クラス。
20	IOError 存在しないファイルを開こうとしたときのprintステートメントやopen（）関数など、入出力操作が失敗したときに発生します。
21	OSError オペレーティングシステム関連のエラーに対して発生します。
22	SyntaxError Python構文にエラーがあるときに発生します。
23	IndentationError インデントが適切に指定されていない場合に発生します。
24	SystemError インタープリターが内部問題を検出したときに発生しますが、このエラーが発生した場合、Pythonインタープリターは終了しません。
25	SystemExit sys.exit（）関数を使用してPythonインタープリターが終了すると発生します。 コードで処理されない場合、インタープリターは終了します。
26	TypeError 指定されたデータ型に対して無効な操作または機能が試行されたときに発生します。
27	ValueError データ型の組み込み関数に有効な引数の型があるが、引数に無効な値が指定されている場合に発生します。
28	RuntimeError 生成されたエラーがどのカテゴリにも該当しない場合に発生します。
29	NotImplementedError 継承されたクラスに実装する必要がある抽象メソッドが実際に実装されていないときに発生します。

Pythonのアサーション

アサーションとは、プログラムのテストが完了したときにオンまたはオフにできる健全性チェックです。

• アサーションを考える最も簡単な方法は、それを raise-if ステートメント（またはより正確に言えば、raise-if-notステートメント）に例えることです。 式がテストされ、結果が偽になると、例外が発生します。
• アサーションは、バージョン1.5で導入されたPythonの最新のキーワードであるassertステートメントによって実行されます。
• プログラマーは、有効な入力をチェックするために、および有効な出力をチェックするための関数呼び出しの後に、関数の先頭にアサーションを配置することがよくあります。

assertステートメント

assert文が検出されると、Pythonは付随する式を評価しますが、これは正しいことです。 式が偽の場合、Pythonは_AssertionError_例外を発生させます。

assertの構文は次のとおりです-

assert Expression[, Arguments]

アサーションが失敗した場合、PythonはArgumentExpressionをAssertionErrorの引数として使用します。 AssertionError例外は、try-exceptステートメントを使用して、他の例外と同様にキャッチおよび処理できます。 それらが処理されない場合、プログラムを終了し、トレースバックを生成します。

例

所定の温度をケルビン度から華氏度に変換する関数を次に示します。 0°Kはそれと同じくらい寒いので、負の温度を見た場合、関数は消滅します-

#!/usr/bin/python3

def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32

print (KelvinToFahrenheit(273))
print (int(KelvinToFahrenheit(505.78)))
print (KelvinToFahrenheit(-5))

上記のコードが実行されると、次の結果が生成されます-

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in <module>
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

例外とは何ですか？

例外はイベントであり、プログラムの実行中に発生し、プログラムの命令の通常の流れを妨害します。 一般に、Pythonスクリプトが対処できない状況に遭遇すると、例外が発生します。 例外は、エラーを表すPythonオブジェクトです。

Pythonスクリプトが例外を発生させた場合、すぐに例外を処理する必要があります。そうでない場合、終了して終了します。

例外処理

例外を発生させる可能性のある_suspicious_コードがある場合は、疑わしいコードを* try：ブロックに配置することでプログラムを保護できます。 try：ブロックの後に、 except：*ステートメントを含め、問題をできるだけエレガントに処理するコードのブロックを続けます。

構文

_try …​. except …​ else_ブロックの簡単な構文を次に示します-

try:
   You do your operations here
   ......................
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

上記の構文に関する重要な点はいくつかあります-

• 1つのtryステートメントに複数のexceptステートメントを含めることができます。 これは、tryブロックにさまざまなタイプの例外をスローする可能性のあるステートメントが含まれる場合に役立ちます。
• 例外を処理する汎用のexcept節を提供することもできます。
• except節の後に、else節を含めることができます。 try：ブロックのコードが例外を発生させない場合、else-blockのコードが実行されます。
• else-blockは、try：ブロックの保護を必要としないコードに適した場所です。

例

この例では、ファイルを開き、ファイルにコンテンツを書き込み、問題がまったくないため、正常に出力されます-

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print ("Error: can\'t find file or read data")
else:
   print ("Written content in the file successfully")
   fh.close()

これは、次の結果を生成します-

Written content in the file successfully

例

この例では、書き込み権限がないファイルを開こうとするため、例外が発生します-

#!/usr/bin/python3

try:
   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print ("Error: can\'t find file or read data")
else:
   print ("Written content in the file successfully")

これは、次の結果を生成します-

Error: can't find file or read data

例外のない例外条項

また、次のように定義された例外なしでexceptステートメントを使用することができます-

try:
   You do your operations here
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

このような try-except ステートメントは、発生するすべての例外をキャッチします。 ただし、この種のtry-exceptステートメントを使用することは、すべての例外をキャッチしますが、発生する可能性のある問題の根本原因をプログラマに識別させないため、良いプログラミング手法とは見なされません。

複数の例外を伴うexcept節

また、次のように複数の例外を処理するために同じ_except_ステートメントを使用することができます-

try:
   You do your operations here
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list,
   then execute this block.
   ......................
else:
   If there is no exception then execute this block.

try-finally節

• finally：ブロックと try：*ブロックを使用できます。 * finally：*ブロックは、tryブロックで例外が発生したかどうかにかかわらず、実行する必要があるコードを配置する場所です。 try-finallyステートメントの構文はこれです-

try:
   You do your operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

注-except句またはfinally句を指定できますが、両方は指定できません。 finally句と一緒に_else_句を使用することはできません。

例

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
finally:
   print ("Error: can\'t find file or read data")
   fh.close()

あなたが書き込みモードでファイルを開く権限を持っていない場合、これは次の結果を生成します-

Error: can't find file or read data

同じ例を次のようにもっときれいに書くことができます-

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   try:
      fh.write("This is my test file for exception handling!!")
   finally:
      print ("Going to close the file")
      fh.close()
except IOError:
   print ("Error: can\'t find file or read data")

これは、次の結果を生成します-

Going to close the file

_try_ブロックで例外がスローされると、実行はすぐに_finally_ブロックに渡されます。 _finally_ブロック内のすべてのステートメントが実行された後、例外が再度発生し、_try-except_ステートメントの次の上位レイヤーに存在する場合、_except_ステートメントで処理されます。

例外の引数

例外には、_argument_を含めることができます。これは、問題に関する追加情報を提供する値です。 引数の内容は例外によって異なります。 あなたは次のようにexcept節で変数を提供することにより、例外の引数をキャプチャします-

try:
   You do your operations here
   ......................
except ExceptionType as Argument:
   You can print value of Argument here...

単一の例外を処理するコードを記述する場合、exceptステートメントで例外の名前の後に変数を続けることができます。 複数の例外をトラップする場合は、例外のタプルの後に変数を続けることができます。

この変数は、ほとんど例外の原因を含む例外の値を受け取ります。 変数は、単一の値またはタプルの形式で複数の値を受け取ることができます。 このタプルには通常、エラー文字列、エラー番号、およびエラーの場所が含まれます。

例

以下は、単一の例外の例です-

#!/usr/bin/python3

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError as Argument:
      print ("The argument does not contain numbers\n", Argument)

# Call above function here.
temp_convert("xyz")

これは、次の結果を生成します-

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

例外を発生させる

raiseステートメントを使用して、いくつかの方法で例外を発生させることができます。 raise ステートメントの一般的な構文は次のとおりです-

構文

raise [Exception [, args [, traceback]]]

ここで、_Exception_は例外のタイプ（たとえば、NameError）であり、_argument_は例外引数の値です。 引数はオプションです。指定しない場合、例外引数はNoneです。

最後の引数tracebackもオプションであり（実際にはほとんど使用されません）、存在する場合は、例外に使用されるtracebackオブジェクトです。

例

例外は、文字列、クラス、またはオブジェクトです。 Pythonコアで発生する例外のほとんどはクラスであり、引数はクラスのインスタンスです。 新しい例外の定義は非常に簡単で、次のように行うことができます-

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

注-例外をキャッチするには、「except」句は、クラスオブジェクトまたは単純な文字列としてスローされる同じ例外を参照する必要があります。 たとえば、上記の例外をキャプチャするには、次のようにexcept節を記述する必要があります-

try:
   Business Logic here...
except Exception as e:
   Exception handling here using e.args...
else:
   Rest of the code here...

次の例は、例外を発生させる使用方法を示しています-

#!/usr/bin/python3

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

try:
   l = functionName(-10)
   print ("level = ",l)
except Exception as e:
   print ("error in level argument",e.args[0])

これにより、次の結果が生成されます

error in level argument -10

ユーザー定義の例外

Pythonでは、標準の組み込み例外からクラスを派生させることにより、独自の例外を作成することもできます。

_RuntimeError_に関連する例を次に示します。 ここでは、_RuntimeError_からサブクラス化されたクラスが作成されます。 これは、例外がキャッチされたときに、より具体的な情報を表示する必要がある場合に役立ちます。

tryブロックでは、ユーザー定義の例外が発生し、exceptブロックでキャッチされます。 変数eは、_Networkerror_クラスのインスタンスを作成するために使用されます。

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

したがって、上記のクラスを定義したら、次のように例外を発生させることができます-

try:
   raise Networkerror("Bad hostname")
except Networkerror,e:
   print e.args

Python 3-オブジェクト指向

Pythonは、存在して以来オブジェクト指向言語でした。 このため、クラスとオブジェクトの作成と使用は非常に簡単です。 この章は、Pythonのオブジェクト指向プログラミングサポートの使用に関する専門家になるのに役立ちます。

オブジェクト指向（OO）プログラミングの経験がない場合は、入門コースまたは少なくとも何らかのチュートリアルを参照して、基本的な概念を把握してください。

しかし、ここではあなたを助けるためにオブジェクト指向プログラミング（OOP）の小さな紹介です-

OOP用語の概要

• クラス-クラスのオブジェクトを特徴付ける一連の属性を定義するオブジェクトのユーザー定義プロトタイプ。 属性は、データメンバー（クラス変数とインスタンス変数）とメソッドであり、ドット表記でアクセスします。
• クラス変数-クラスのすべてのインスタンスで共有される変数。 クラス変数はクラス内で定義されますが、クラスのメソッドの外部で定義されます。 クラス変数は、インスタンス変数ほど頻繁には使用されません。
• データメンバー-クラスとそのオブジェクトに関連付けられたデータを保持するクラス変数またはインスタンス変数。
• 関数のオーバーロード-特定の関数への複数の動作の割り当て。 実行される操作は、関連するオブジェクトまたは引数のタイプによって異なります。
• インスタンス変数-メソッド内で定義され、クラスの現在のインスタンスにのみ属する変数。
• 継承-クラスの特性を、それから派生した他のクラスに転送します。
• インスタンス-特定のクラスの個々のオブジェクト。 たとえば、クラスCircleに属するオブジェクトobjは、クラスCircleのインスタンスです。
• インスタンス-クラスのインスタンスの作成。
• メソッド-クラス定義で定義されている特別な種類の関数。
• オブジェクト-クラスによって定義されるデータ構造の一意のインスタンス。 オブジェクトは、データメンバー（クラス変数とインスタンス変数）とメソッドの両方で構成されます。
• 演算子のオーバーロード-特定の演算子への複数の関数の割り当て。

クラスを作成する

_class_ステートメントは、新しいクラス定義を作成します。 クラスの名前は、キーワード_class_の直後に次のようにコロンが続きます-

class ClassName:
   'Optional class documentation string'
   class_suite

• クラスにはドキュメント文字列があり、 _ ClassName .doc_ からアクセスできます。
• class_suite は、クラスメンバー、データ属性、および関数を定義するすべてのコンポーネントステートメントで構成されます。

例

以下は、単純なPythonクラスの例です-

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)

• 変数_empCount_は、値がこのクラスのaのすべてのインスタンス間で共有されるクラス変数です。 これは、クラス内またはクラス外から_Employee.empCount_としてアクセスできます。
• 最初のメソッド_ init（）_は特別なメソッドで、このクラスの新しいインスタンスを作成するときにPythonが呼び出すクラスコンストラクターまたは初期化メソッドと呼ばれます。
• 各メソッドの最初の引数が_self_であることを除いて、通常の関数のような他のクラスメソッドを宣言します。 Pythonは_self_引数をリストに追加します;メソッドを呼び出すときに含める必要はありません。

インスタンスオブジェクトの作成

クラスのインスタンスを作成するには、クラス名を使用してクラスを呼び出し、その_init_メソッドが受け入れる引数を渡します。

This would create first object of Employee class
emp1 = Employee("Zara", 2000)
This would create second object of Employee class
emp2 = Employee("Manni", 5000)

属性へのアクセス

オブジェクトのドット演算子を使用して、オブジェクトの属性にアクセスします。 クラス変数は、次のようにクラス名を使用してアクセスされます-

emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)

今、すべての概念をまとめる-

#!/usr/bin/python3

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)


#This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
#This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)

上記のコードが実行されると、次の結果が生成されます-

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

あなたはいつでもクラスやオブジェクトの属性を追加、削除、変更できます-

emp1.salary = 7000  # Add an 'salary' attribute.
emp1.name = 'xyz'  # Modify 'age' attribute.
del emp1.salary  # Delete 'age' attribute.

通常のステートメントを使用して属性にアクセスする代わりに、次の機能を使用できます-

• * getattr（obj、name [、default]）*-オブジェクトの属性にアクセスします。
• * hasattr（obj、name）*-属性が存在するかどうかを確認します。
• * setattr（obj、name、value）*-属性を設定します。 属性が存在しない場合、作成されます。
• * delattr（obj、name）*-属性を削除します。

hasattr(emp1, 'salary')    # Returns true if 'salary' attribute exists
getattr(emp1, 'salary')    # Returns value of 'salary' attribute
setattr(emp1, 'salary', 7000) # Set attribute 'salary' at 7000
delattr(emp1, 'salary')    # Delete attribute 'salary'

組み込みクラスの属性

すべてのPythonクラスは組み込みの属性を追跡し続け、他の属性と同様にドット演算子を使用してアクセスできます-

• dict -クラスの名前空間を含む辞書。
• doc -クラスのドキュメント文字列または未定義の場合はなし。
• name -クラス名。
• module -クラスが定義されているモジュール名。 この属性は、対話モードでは「main」です。
• bases -基本クラスリストに出現する順序で、基本クラスを含む空の可能性のあるタプル。

上記のクラスの場合、これらすべての属性にアクセスしてみましょう-

#!/usr/bin/python3

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)

emp1 = Employee("Zara", 2000)
emp2 = Employee("Manni", 5000)
print ("Employee.__doc__:", Employee.__doc__)
print ("Employee.__name__:", Employee.__name__)
print ("Employee.__module__:", Employee.__module__)
print ("Employee.__bases__:", Employee.__bases__)
print ("Employee.__dict__:", Employee.__dict__ )

上記のコードが実行されると、次の結果が生成されます-

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: (<class 'object'>,)
Employee.__dict__: {
   'displayCount': <function Employee.displayCount at 0x0160D2B8>,
   '__module__': '__main__', '__doc__': 'Common base class for all employees',
   'empCount': 2, '__init__':
   <function Employee.__init__ at 0x0124F810>, 'displayEmployee':
   <function Employee.displayEmployee at 0x0160D300>,
   '__weakref__':
   <attribute '__weakref__' of 'Employee' objects>, '__dict__':
   <attribute '__dict__' of 'Employee' objects>
}

オブジェクトの破棄（ガベージコレクション）

Pythonは、不要なオブジェクト（組み込み型またはクラスインスタンス）を自動的に削除して、メモリスペースを解放します。 Pythonが使用されなくなったメモリブロックを定期的に回収するプロセスは、ガベージコレクションと呼ばれます。

Pythonのガベージコレクターは、プログラムの実行中に実行され、オブジェクトの参照カウントがゼロに達するとトリガーされます。 オブジェクトの参照カウントは、それを指すエイリアスの数が変わると変わります。

オブジェクトの参照カウントは、新しい名前が割り当てられるか、コンテナ（リスト、タプル、または辞書）に配置されると増加します。 オブジェクトの参照カウントは、_del_で削除されるか、参照が再割り当てされるか、参照が範囲外になると減少します。 オブジェクトの参照カウントがゼロに達すると、Pythonはそれを自動的に収集します。

a = 40      # Create object 
b = a       # Increase ref. count  of 
c = [b]     # Increase ref. count  of 

del a       # Decrease ref. count  of 
b = 100     # Decrease ref. count  of 
c[0] = -1   # Decrease ref. count  of

通常、ガベージコレクターが孤立したインスタンスを破棄し、そのスペースを再利用することに気付かないでしょう。 ただし、クラスは、インスタンスが破棄されようとしているときに呼び出されるデストラクタと呼ばれる特別なメソッド_ del（）_を実装できます。 このメソッドは、インスタンスで使用されているメモリ以外のリソースをクリーンアップするために使用される場合があります。

例

このdel（）デストラクタは、破棄されようとしているインスタンスのクラス名を出力します-

#!/usr/bin/python3

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print (class_name, "destroyed")

pt1 = Point()
pt2 = pt1
pt3 = pt1
print (id(pt1), id(pt2), id(pt3))   # prints the ids of the obejcts
del pt1
del pt2
del pt3

上記のコードが実行されると、次の結果が生成されます-

140338326963984 140338326963984 140338326963984
Point destroyed

注-理想的には、クラスを別のファイルで定義し、_import_ステートメントを使用してメインプログラムファイルにインポートする必要があります。

上記の例では、Pointクラスの定義が_point.py_に含まれており、その中に他の実行可能コードがないと想定しています。

#!/usr/bin/python3
import point

p1 = point.Point()

クラスの継承

ゼロから始める代わりに、新しいクラス名の後に括弧で親クラスをリストすることにより、既存のクラスから派生することにより、クラスを作成できます。

子クラスは親クラスの属性を継承し、それらの属性を子クラスで定義されているかのように使用できます。 子クラスは、親からのデータメンバーとメソッドをオーバーライドすることもできます。

構文

派生クラスは、親クラスのように宣言されます。ただし、継承する基本クラスのリストは、クラス名の後に指定されます-

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

例

#!/usr/bin/python3

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print ("Calling parent constructor")

   def parentMethod(self):
      print ('Calling parent method')

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print ("Parent attribute :", Parent.parentAttr)

class Child(Parent): # define child class
   def __init__(self):
      print ("Calling child constructor")

   def childMethod(self):
      print ('Calling child method')

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method

上記のコードが実行されると、次の結果が生成されます-

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

同様の方法で、次のように複数の親クラスからクラスを駆動することができます-

class A:        # define your class A
.....

class B:         # define your calss B
.....

class C(A, B):   # subclass of A and B
.....

issubclass（）またはisinstance（）関数を使用して、2つのクラスとインスタンスの関係を確認できます。

• * issubclass（s​​ub、sup）ブール関数は、指定されたサブクラス *sub が実際にスーパークラス sup のサブクラスである場合、Trueを返します。
• _obj_がクラス_Class_のインスタンスであるか、クラスのサブクラスのインスタンスである場合、* isinstance（obj、Class）*ブール関数はTrueを返します。

メソッドのオーバーライド

親クラスのメソッドはいつでもオーバーライドできます。 親のメソッドをオーバーライドする理由の1つは、サブクラスで特別な機能または異なる機能が必要になる場合があることです。

例

#!/usr/bin/python3

class Parent:        # define parent class
   def myMethod(self):
      print ('Calling parent method')

class Child(Parent): # define child class
   def myMethod(self):
      print ('Calling child method')

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

上記のコードが実行されると、次の結果が生成されます-

Calling child method

ベースのオーバーロード方法

次の表は、独自のクラスでオーバーライドできるいくつかの一般的な機能を示しています-

Sr.No.	Method, Description & Sample Call
1	init ( self [,args…​] ) コンストラクター（オプションの引数を使用） サンプル呼び出し：obj = className（args）
2	del( self ) デストラクタ、オブジェクトを削除します サンプル呼び出し：del obj
3	repr( self ) 評価可能な文字列表現 サンプル呼び出し：repr（obj）
4	str( self ) 印刷可能な文字列表現 サンプル呼び出し：str（obj）
5	cmp ( self, x ) オブジェクト比較 サンプル呼び出し：cmp（obj、x）

演算子のオーバーロード

2次元ベクトルを表すVectorクラスを作成したとします。 プラス演算子を使用してそれらを追加するとどうなりますか？ Pythonが大声で叫ぶでしょう。

ただし、クラスで_add_メソッドを定義してベクトル加算を実行すると、プラス演算子が期待どおりに動作します-

例

#!/usr/bin/python3

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)

   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

上記のコードが実行されると、次の結果が生成されます-

Vector(7,8)

データ隠蔽

オブジェクトの属性は、クラス定義の外部で表示される場合と表示されない場合があります。 属性に二重アンダースコアプレフィックスを付ける必要があります。これらの属性は部外者には直接表示されません。

例

#!/usr/bin/python3

class JustCounter:
   __secretCount = 0

   def count(self):
      self.__secretCount += 1
      print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.__secretCount)

上記のコードが実行されると、次の結果が生成されます-

1
2
Traceback (most recent call last):
   File "test.py", line 12, in <module>
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Pythonは、名前を内部的に変更してクラス名を含めることにより、これらのメンバーを保護します。 _object._className__attrName_などの属性にアクセスできます。 次のように最後の行を置き換える場合、それはあなたのために動作します-

.........................
print (counter._JustCounter__secretCount)

上記のコードが実行されると、次の結果が生成されます-

1
2
2

Python 3-正規表現

_正規表現_は、パターンに保持されている特殊な構文を使用して、他の文字列または文字列のセットを一致または検索するのに役立つ特殊な文字シーケンスです。 正規表現は、UNIXの世界で広く使用されています。

モジュール re は、PythonでのPerlのような正規表現を完全にサポートします。 正規表現のコンパイル中または使用中にエラーが発生した場合、 re モジュールは例外 re.error を発生させます。

正規表現の処理に使用される2つの重要な関数について説明します。 それにもかかわらず、最初に小さなこと：さまざまな文字があり、正規表現で使用されると特別な意味を持ちます。 正規表現を扱う際の混乱を避けるために、Raw文字列を* r’expression '*として使用します。

単一の文字に一致する基本パターン

Sr.No.	Expression & Matches
1	a, X, 9, < 通常の文字は、正確に一致します。
2	（期間） * 改行「\ n」を除く任意の1文字と一致します
3	\w* 「単語」文字に一致します：文字または数字またはアンダーバー[a-zA-Z0-9_]。
4	\W 単語以外の文字に一致します。
5	\b 単語と非単語の境界
6	\s 単一の空白文字に一致します-スペース、改行、リターン、タブ
7	\S 空白以外の文字に一致します。
8	\t, \n, \r タブ、改行、リターン
9	\d 10進数[0-9]
10	^ 文字列の先頭に一致します
11	DOLLAR 文字列の末尾に一致
12	\ キャラクターの「特殊性」を抑制します。

コンパイルフラグ

コンパイルフラグを使用すると、正規表現の動作方法のいくつかの側面を変更できます。 reモジュールでは、フラグを IGNORECASE などの長い名前とIなどの短い1文字の形式の2つの名前で使用できます。

Sr.No.	Flag & Meaning
1	ASCII, A \ w、\ b、\ s、および\ dなどのエスケープを、それぞれのプロパティを持つASCII文字でのみ一致させます。
2	DOTALL, S 改行を含む任意の文字を作成、一致
3	IGNORECASE, I 大文字と小文字を区別しない一致を行う
4	LOCALE, L ロケール対応の一致を行う
5	MULTILINE, M 複数行一致、^および＆dollar;に影響
6	VERBOSE, X (for ‘extended’) 詳細なREを有効にします。これは、よりきれいに理解できるように編成できます

マッチ機能

この関数は、オプションの_flags_を使用して、RE _pattern_を_string_に一致させようとします。

この関数の構文は次のとおりです-

re.match(pattern, string, flags = 0)

ここにパラメータの説明があります-

Sr.No.	Parameter & Description
1	pattern これは一致する正規表現です。
2	string これはストリングであり、ストリングの先頭のパターンに一致するように検索されます。
3	flags ビットごとのOR（

_re.match_関数は、成功すると match オブジェクト、失敗すると None を返します。 match オブジェクトのgroup（num）または_groups（）_関数を使用して、一致した式を取得します。

Sr.No.	Match Object Method & Description
1	group(num = 0) このメソッドは、完全一致（または特定のサブグループnum）を返します
2	groups() このメソッドは、一致するすべてのサブグループをタプルで返します（ない場合は空になります）

例

#!/usr/bin/python3
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print ("matchObj.group() : ", matchObj.group())
   print ("matchObj.group(1) : ", matchObj.group(1))
   print ("matchObj.group(2) : ", matchObj.group(2))
else:
   print ("No match!!")

上記のコードが実行されると、次の結果が生成されます-

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

検索機能

この関数は、オプションの_flags_を使用して、_string_内で最初にRE _pattern_が出現する場所を検索します。

この関数の構文は次のとおりです-

re.search(pattern, string, flags = 0)

ここにパラメータの説明があります-

Sr.No.	Parameter & Description
1	pattern これは一致する正規表現です。
2	string これは文字列であり、文字列内の任意のパターンに一致するように検索されます。
3	flags ビットごとのOR（

_re.search_関数は、成功すると match オブジェクトを返し、失敗すると none を返します。 match オブジェクトの_group（num）_または_groups（）_関数を使用して、一致した式を取得します。

Sr.No.	Match Object Method & Description
1	group(num = 0) このメソッドは、完全一致（または特定のサブグループnum）を返します
2	groups() このメソッドは、一致するすべてのサブグループをタプルで返します（ない場合は空になります）

例

#!/usr/bin/python3
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print ("searchObj.group() : ", searchObj.group())
   print ("searchObj.group(1) : ", searchObj.group(1))
   print ("searchObj.group(2) : ", searchObj.group(2))
else:
   print ("Nothing found!!")

上記のコードが実行されると、次の結果が生成されます-

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

マッチングと検索

Pythonは、正規表現に基づいた2つの異なるプリミティブ操作を提供します。

例

#!/usr/bin/python3
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print ("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print ("search --> searchObj.group() : ", searchObj.group())
else:
   print ("Nothing found!!")

上記のコードが実行されると、次の結果が生成されます-

No match!!
search --> matchObj.group() :  dogs

検索と置換

正規表現を使用する最も重要な re メソッドの1つは sub です。

構文

re.sub(pattern, repl, string, max=0)

このメソッドは、_string_のRE _pattern_のすべての出現を_repl_に置き換え、_max_が指定されていない限り、すべての出現を置き換えます。 このメソッドは変更された文字列を返します。

例

#!/usr/bin/python3
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print ("Phone Num : ", num)

# Remove anything other than digits
num = re.sub(r'\D', "", phone)
print ("Phone Num : ", num)

上記のコードが実行されると、次の結果が生成されます-

Phone Num :  2004-959-559
Phone Num :  2004959559

正規表現修飾子：オプションフラグ

正規表現リテラルには、マッチングのさまざまな側面を制御するオプションの修飾子が含まれる場合があります。 修飾子はオプションのフラグとして指定されます。 前述のように、排他的OR（|）を使用して複数の修飾子を指定でき、これらの修飾子のいずれかで表すことができます-

Sr.No.	Modifier & Description
1	re.I 大文字と小文字を区別しないマッチングを実行します。
2	re.L 現在のロケールに従って単語を解釈します。 この解釈は、アルファベットのグループ（\ wと\ W）、および単語の境界の動作（\ bと\ B）に影響します。
3	re.M ＆dollar;を作成します（文字列の最後だけでなく）行の最後に一致し、^（文字列の最初だけでなく）任意の行の先頭に一致させます。
4	re.S 改行を含む任意の文字にピリオド（ドット）を一致させます。
5	re.U Unicode文字セットに従って文字を解釈します。 このフラグは、\ w、\ W、\ b、\ Bの動作に影響します。
6	re.X 「キューター」正規表現構文を許可します。 空白を無視し（セット[]内またはバックスラッシュでエスケープされた場合を除く）、エスケープされていない＃をコメントマーカーとして扱います。

正規表現パターン

制御文字を除いて、（＆plus;？ 。 * ^＆dollar; （）[] \ {} | \）、すべての文字が一致します。 制御文字の前にバックスラッシュを付けることにより、制御文字をエスケープできます。

次の表は、Pythonで利用可能な正規表現の構文を示しています-

____これは、Pythonの正規表現構文のリストです。

Sr.No.	Parameter & Description
1	^ 行頭に一致します。
2	DOLLAR 行末に一致します。
3	. 改行を除く任意の1文字に一致します。 mオプションを使用すると、改行も一致させることができます。
4	[…​] 大括弧内の任意の1文字に一致します。
5	[^…​] 括弧内にない任意の1文字と一致します
6	re* 前の表現の0回以上の出現に一致します。
7	rePLUS 先行表現の1回以上の出現に一致します。
8	re? 前の表現の0または1回の出現に一致します。
9	re\{ n} 直前の表現の正確にn個の出現に一致します。
10	re\{ n,} 前の表現のn回以上の出現に一致します。
11	re\{ n, m} 先行表現の少なくともn回、最大m回の出現に一致します。
12	*a
b* aまたはbのいずれかに一致します。	13
(re) 正規表現をグループ化し、一致したテキストを記憶します。	14
(?imx) 正規表現内でi、m、またはxオプションを一時的に切り替えます。 括弧内にある場合、その領域のみが影響を受けます。	15
(?-imx) 正規表現内でi、m、またはxオプションを一時的にオフにします。 括弧内にある場合、その領域のみが影響を受けます。	16
(?: re) 一致したテキストを記憶せずに正規表現をグループ化します。	17
(?imx: re) 括弧内のi、m、またはxオプションを一時的に切り替えます。	18
(?-imx: re) 括弧内のi、m、またはxオプションを一時的にオフにします。	19
(?#…​) コメント。	20
(?= re) パターンを使用して位置を指定します。 範囲はありません。	21
(?! re) パターン否定を使用して位置を指定します。 範囲はありません。	22
(?> re) バックトラックせずに独立したパターンに一致します。	23
\w 単語の文字に一致します。	24
\W 単語以外の文字に一致します。	25
\s 空白に一致します。 [\ t \ n \ r \ f]と同等です。	26
\S 空白以外に一致します。	27
\d 数字と一致します。 [0-9]と同等です。	28
\D 数字以外に一致します。	29
\A 文字列の先頭に一致します。	30
\Z 文字列の末尾に一致します。 改行が存在する場合、改行の直前に一致します。	31
\z 文字列の末尾に一致します。	32
\G 最後の一致が終了したポイントに一致します。	33
\b 大括弧の外にある場合、単語の境界に一致します。 括弧内にある場合、バックスペース（0x08）に一致します。	34
\B 単語の境界以外に一致します。	35
\n, \t, etc. 改行、キャリッジリターン、タブなどに一致します。	36
\1…​\9 n番目のグループ化された部分式に一致します。	37

正規表現の例

リテラル文字

Sr.No.	Example & Description
1	python 「python」に一致します。

キャラクタークラス

Sr.No.	Example & Description
1	[Pp]ython 「Python」または「python」に一致
2	rub[ye] 「ruby」または「rube」に一致
3	[aeiou] いずれかの小文字の母音に一致
4	[0-9] 任意の数字に一致。 [0123456789]と同じ
5	[a-z] 小文字のASCII文字に一致
6	[A-Z] 大文字のASCII文字に一致
7	[a-zA-Z0-9] 上記のいずれかに一致
8	[^aeiou] 小文字の母音以外のものに一致する
9	[^0-9] 数字以外のものに一致する

特殊文字クラス

Sr.No.	Example & Description
1	. 改行を除く任意の文字に一致
2	\d 数字と一致：[0-9]
3	\D 数字以外と一致：[^ 0-9]
4	\s 空白文字に一致する：[\ t \ r \ n \ f]
5	\S 空白以外に一致：[^ \ t \ r \ n \ f]
6	\w 単一の単語文字に一致：[A-Za-z0-9_]
7	\W 単語以外の文字に一致：[^ A-Za-z0-9_]

繰り返しの場合

Sr.No.	Example & Description
1	ruby? 「rub」または「ruby」に一致：yはオプションです
2	ruby* 「rub」と0以上のysに一致
3	rubyPLUS 「rub」と1つ以上のysに一致
4	\d{3} 正確に3桁に一致
5	\d\{3,} 3桁以上の数字に一致
6	\d\{3,5} 3、4、または5桁に一致

貪欲でない繰り返し

これは繰り返しの最小数に一致します-

Sr.No.	Example & Description
1	<.>* 貪欲な繰り返し：「<python> perl>」に一致
2	<.?>* 貪欲でない：「<python> perl>」の「<python>」に一致

かっこでグループ化する

Sr.No.	Example & Description
1	\D\dPLUS グループなし：＆plus; \ dを繰り返します
2	(\D\d)PLUS グループ化：＆plus; \ D \ dのペアを繰り返します
3	([Pp]ython(,)?)PLUS 「Python」、「Python、python、python」などに一致します。

後方参照

これは以前に一致したグループに再び一致します-

Sr.No.	Example & Description
1	([Pp])ython&\1ails python＆pailsまたはPython＆Pailsに一致
2	(['"])[^\1]\1* 一重引用符または二重引用符で囲まれた文字列。 \ 1は、最初のグループが一致したものに一致します。 \ 2は、2番目のグループが一致したものに一致します。

代替案

Sr.No.	Example & Description
1	*python
perl* 「python」または「perl」に一致	2
*rub(y	le)* 「ルビー」または「ルーブル」に一致
3	*Python(!PLUS

アンカー

これには、一致位置を指定する必要があります。

Sr.No.	Example & Description
1	^Python 文字列または内部行の先頭で「Python」に一致
2	PythonDOLLAR 文字列または行の末尾で「Python」に一致
3	\APython 文字列の先頭で「Python」に一致
4	Python\Z 文字列の最後で「Python」に一致
5	\bPython\b 単語の境界で「Python」に一致
6	\brub\B \ Bは非単語境界です：「rube」および「ruby」の「rub」に一致しますが、単独ではありません
7	Python(?=!) 感嘆符が続く場合は、「Python」に一致します。
8	Python(?!!) 感嘆符が続かない場合は、「Python」に一致します。

括弧付きの特別な構文

Sr.No.	Example & Description
1	R(?#comment) 「R」に一致します。 残りはすべてコメントです
2	R(?i)uby 「uby」に一致している間は大文字と小文字を区別しません
3	R(?i:uby) 同上
4	*rub(?:y

Python 3-CGIプログラミング

Common Gateway Interface（CGI）は、Webサーバーとカスタムスクリプト間で情報を交換する方法を定義する一連の標準です。 CGI仕様は現在、NCSAによって維持されています。

CGIとは何ですか？

• Common Gateway Interface（CGI）は、HTTPサーバーなどの情報サーバーとインターフェイスする外部ゲートウェイプログラムの標準です。
• 現在のバージョンはCGI/1.1で、CGI/1.2は進行中です。

ウェブブラウジング

CGIの概念を理解するために、ハイパーリンクをクリックして特定のWebページまたはURLを閲覧したときに何が起こるかを見てみましょう。

• ブラウザはHTTP Webサーバーにアクセスし、URL、つまりファイル名を要求します。
• WebサーバーはURLを解析し、ファイル名を探します。 そのファイルが見つかった場合、ブラウザに送り返します。それ以外の場合は、間違ったファイルを要求したことを示すエラーメッセージを送信します。 *WebブラウザはWebサーバーからの応答を受け取り、受信したファイルまたはエラーメッセージを表示します。

ただし、特定のディレクトリ内のファイルが要求されるたびに、そのファイルが送り返されないようにHTTPサーバーを設定することは可能です。代わりに、プログラムとして実行され、そのプログラム出力がブラウザに表示されるように送り返されます。 この機能はCommon Gateway InterfaceまたはCGIと呼ばれ、プログラムはCGIスクリプトと呼ばれます。 これらのCGIプログラムは、Pythonスクリプト、PERLスクリプト、シェルスクリプト、CまたはC ++プログラムなどです。

CGIアーキテクチャ図

CGIアーキテクチャ

Webサーバーのサポートと構成

CGIプログラミングを進める前に、WebサーバーがCGIをサポートし、CGIプログラムを処理するように構成されていることを確認してください。 HTTPサーバーによって実行されるすべてのCGIプログラムは、事前に構成されたディレクトリに保持されます。 このディレクトリはCGIディレクトリと呼ばれ、慣例により/var/www/cgi-binと名付けられます。 慣例により、CGIファイルの拡張子はasです。* cgi、ただし、ファイルをpython拡張子 *.py で保持することもできます。

デフォルトでは、Linuxサーバーは/var/wwwのcgi-binディレクトリー内のスクリプトのみを実行するように構成されています。 CGIスクリプトを実行する他のディレクトリを指定する場合は、httpd.confファイルの次の行をコメント化します-

<Directory "/var/www/cgi-bin">
   AllowOverride None
   Options ExecCGI
   Order allow,deny
   Allow from all
</Directory>

<Directory "/var/www/cgi-bin">
Options All
</Directory>

ここでは、Webサーバーが正常に稼働しており、PerlやShellなどの他のCGIプログラムを実行できることを前提としています。

最初のCGIプログラム

これは、link：/cgi-bin/hello.py [hello.py]というCGIスクリプトにリンクされた簡単なリンクです。 このファイルは/var/www/cgi-binディレクトリに保存され、次の内容が含まれています。 CGIプログラムを実行する前に、 chmod 755 hello.py UNIXコマンドを使用してファイルのモードを変更し、ファイルを実行可能にしてください。

#!/usr/bin/python

print ("Content-type:text/html\r\n\r\n")
print ('<html>')
print ('<head>')
print ('<title>Hello Word - First CGI Program</title>')
print ('</head>')
print ('<body>')
print ('<h2>Hello Word! This is my first CGI program</h2>')
print ('</body>')
print ('</html>')

注-スクリプトの最初の行はPython実行可能ファイルへのパスでなければなりません。 Linuxでは＃！/usr/bin/python3になります

ブラウザに次のURLを入力してください

http://localhost:8080/cgi-bin/hello.py

Hello Word! This is my first CGI program

このhello.pyスクリプトは単純なPythonスクリプトであり、出力をSTDOUTファイル、つまり画面に書き込みます。 印刷される最初の行である Content-type：text/html \ r \ n \ r \ n という重要で追加の機能が1つあります。 この行はブラウザに送り返され、ブラウザ画面に表示されるコンテンツタイプを指定します。

これまでに、CGIの基本概念を理解している必要があり、Pythonを使用して多くの複雑なCGIプログラムを作成できます。 このスクリプトは、他の外部システムとも対話して、RDBMSなどの情報を交換できます。

HTTPヘッダ

行 Content-type：text/html \ r \ n \ r \ n は、コンテンツを理解するためにブラウザに送信されるHTTPヘッダーの一部です。 すべてのHTTPヘッダーは次の形式になります-

HTTP Field Name: Field Content

For Example
Content-type: text/html\r\n\r\n

CGIプログラミングで頻繁に使用する他の重要なHTTPヘッダーはほとんどありません。

Sr.No.	Header & Description
1	Content-type: 返されるファイルの形式を定義するMIME文字列。 例はContent-type：text/htmlです
2	Expires: Date 情報が無効になる日付。 ブラウザがページを更新する必要がある時期を決定するために使用します。 有効な日付文字列の形式は、1998年1月1日12:00:00 GMTです。
3	Location: URL 要求されたURLの代わりに返されるURL。 このフィールドを使用して、リクエストを任意のファイルにリダイレクトできます。
4	Last-modified: Date リソースの最終変更日。
5	Content-length: N 返されるデータの長さ（バイト単位）。 ブラウザはこの値を使用して、ファイルの推定ダウンロード時間を報告します。
6	Set-Cookie: String _string_を介して渡されるCookieを設定します

CGI環境変数

すべてのCGIプログラムは、次の環境変数にアクセスできます。 これらの変数は、CGIプログラムの作成中に重要な役割を果たします。

Sr.No.	Variable Name & Description
1	CONTENT_TYPE コンテンツのデータ型。 クライアントが添付コンテンツをサーバーに送信するときに使用されます。 たとえば、ファイルのアップロード。
2	CONTENT_LENGTH クエリ情報の長さ。 POSTリクエストでのみ使用できます。
3	HTTP_COOKIE 設定されたCookieをキーと値のペアの形式で返します。
4	HTTP_USER_AGENT User-Agent request-headerフィールドには、リクエストを発信したユーザーエージェントに関する情報が含まれています。 Webブラウザーの名前です。
5	PATH_INFO CGIスクリプトのパス。
6	QUERY_STRING GETメソッド要求で送信されるURLエンコードされた情報。
7	REMOTE_ADDR 要求を行っているリモートホストのIPアドレス。 これは、ロギングまたは認証に役立ちます。
8	REMOTE_HOST 要求を行っているホストの完全修飾名。 この情報が利用できない場合、REMOTE_ADDRを使用してIRアドレスを取得できます。
9	REQUEST_METHOD 要求を行うために使用されるメソッド。 最も一般的なメソッドはGETおよびPOSTです。
10	SCRIPT_FILENAME CGIスクリプトへのフルパス。
11	SCRIPT_NAME CGIスクリプトの名前。
12	SERVER_NAME サーバーのホスト名またはIPアドレス
13	SERVER_SOFTWARE サーバーが実行しているソフトウェアの名前とバージョン。

すべてのCGI変数をリストする小さなCGIプログラムを次に示します。 このリンクをクリックして結果を確認してくださいhttp://www.finddevguides.com/cgi-bin/get_env.py[Get Environment]

#!/usr/bin/python

import os

print ("Content-type: text/html\r\n\r\n");
print ("<font size=+1>Environment</font><\br>");
for param in os.environ.keys():
   print ("<b>%20s</b>: %s<\br>" % (param, os.environ[param]))

GETおよびPOSTメソッド

ブラウザからWebサーバーに、そして最終的にはCGIプログラムに何らかの情報を渡す必要がある場合、多くの状況に遭遇したに違いありません。 ほとんどの場合、ブラウザはこの情報をWebサーバーに渡す2つの方法を使用します。 これらのメソッドは、GETメソッドとPOSTメソッドです。

GETメソッドを使用して情報を渡す

GETメソッドは、エンコードされたユーザー情報をページリクエストに追加して送信します。 ページとエンコードされた情報は、？ 次のような文字-

http://www.test.com/cgi-bin/hello.py?key1=value1&key2=value2

• GETメソッドは、ブラウザからWebサーバーに情報を渡すデフォルトのメソッドであり、ブラウザのLocation：boxに表示される長い文字列を生成します。
• サーバーに渡すパスワードまたはその他の機密情報がある場合は、GETメソッドを使用しないでください。
• GETメソッドにはサイズ制限があります。リクエスト文字列で送信できるのは1024文字のみです。
• GETメソッドはQUERY_STRINGヘッダーを使用して情報を送信し、QUERY_STRING環境変数を介してCGIプログラムでアクセスできます。

キーと値のペアをURLと一緒に連結するだけで情報を渡すことができます。または、GETメソッドを使用してHTML <FORM>タグを使用して情報を渡すことができます。

単純なURLの例：Getメソッド

これは、GETメソッドを使用してhello_get.pyプログラムに2つの値を渡す簡単なURLです。

/cgi-bin/hello_get.py?first_name=ZARA&last_name=ALI

以下は、Webブラウザからの入力を処理する hello_get.py スクリプトです。 私たちは cgi モジュールを使用します。これにより、渡された情報へのアクセスが非常に簡単になります-

#!/usr/bin/python

# Import modules for CGI handling
import cgi, cgitb

# Create instance of FieldStorage
form = cgi.FieldStorage()

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print ("Content-type:text/html\r\n\r\n")
print ("<html>")
print ("<head>")
print ("<title>Hello - Second CGI Program</title>")
print ("</head>")
print ("<body>")
print ("<h2>Hello %s %s</h2>" % (first_name, last_name))
print ("</body>")
print ("</html>")

これは、次の結果を生成します-

Hello ZARA ALI

簡単なFORMの例：GETメソッド

この例では、HTML FORMと送信ボタンを使用して2つの値を渡します。 この入力を処理するために同じCGIスクリプトhello_get.pyを使用します。

<form action = "/cgi-bin/hello_get.py" method = "get">
   First Name: <input type = "text" name = "first_name">  <br/>

   Last Name: <input type = "text" name = "last_name"/>
   <input type = "submit" value = "Submit"/>
</form>

上記のフォームの実際の出力は次のとおりです。名と姓を入力し、送信ボタンをクリックして結果を確認します。

名前苗字：

POSTメソッドを使用して情報を渡す

CGIプログラムに情報を渡すより一般的に信頼できる方法は、POSTメソッドです。 これは、GETメソッドとまったく同じ方法で情報をパッケージ化しますが、？の後にテキスト文字列として送信する代わりに URLで別のメッセージとして送信します。 このメッセージは、標準入力の形式でCGIスクリプトに入力されます。

以下は、GETメソッドとPOSTメソッドを処理する同じhello_get.pyスクリプトです。

#!/usr/bin/python

# Import modules for CGI handling
import cgi, cgitb

# Create instance of FieldStorage
form = cgi.FieldStorage()

# Get data from fields
first_name = form.getvalue('first_name')
last_name  = form.getvalue('last_name')

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Hello - Second CGI Program</title>"
print "</head>"
print "<body>"
print "<h2>Hello %s %s</h2>" % (first_name, last_name)
print "</body>"
print "</html>"

HTMLフォームと送信ボタンを使用して2つの値を渡す上記と同じ例をもう一度見てみましょう。 この入力を処理するために同じCGIスクリプトhello_get.pyを使用します。

<form action = "/cgi-bin/hello_get.py" method = "post">
First Name: <input type = "text" name = "first_name"><br/>
Last Name: <input type = "text" name = "last_name"/>

<input type = "submit" value = "Submit"/>
</form>

上記のフォームの実際の出力は次のとおりです。 姓と名を入力し、送信ボタンをクリックして結果を確認します。

名前苗字：

チェックボックスデータをCGIプログラムに渡す

チェックボックスは、複数のオプションを選択する必要がある場合に使用されます。

ここに2つのチェックボックスを持つフォームのHTMLコードの例があります-

<form action = "/cgi-bin/checkbox.cgi" method = "POST" target = "_blank">
   <input type = "checkbox" name = "maths" value = "on"/> Maths
   <input type = "checkbox" name = "physics" value = "on"/> Physics
   <input type = "submit" value = "Select Subject"/>
</form>

このコードの結果は次の形式です-

数学物理学

以下は、Webブラウザからチェックボックスボタンに指定された入力を処理するためのcheckbox.cgiスクリプトです。

#!/usr/bin/python

# Import modules for CGI handling
import cgi, cgitb

# Create instance of FieldStorage
form = cgi.FieldStorage()

# Get data from fields
if form.getvalue('maths'):
   math_flag = "ON"
else:
   math_flag = "OFF"

if form.getvalue('physics'):
   physics_flag = "ON"
else:
   physics_flag = "OFF"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Checkbox - Third CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> CheckBox Maths is : %s</h2>" % math_flag
print "<h2> CheckBox Physics is : %s</h2>" % physics_flag
print "</body>"
print "</html>"

ラジオボタンデータをCGIプログラムに渡す

オプションを1つだけ選択する必要がある場合は、ラジオボタンが使用されます。

これは、2つのラジオボタンがあるフォームのHTMLコードの例です-

<form action = "/cgi-bin/radiobutton.py" method = "post" target = "_blank">
   <input type = "radio" name = "subject" value = "maths"/> Maths
   <input type = "radio" name = "subject" value = "physics"/> Physics
   <input type = "submit" value = "Select Subject"/>
</form>

このコードの結果は次の形式です-

数学物理学

以下は、ラジオボタンのWebブラウザーによって与えられた入力を処理するradiobutton.pyスクリプトです-

#!/usr/bin/python

# Import modules for CGI handling
import cgi, cgitb

# Create instance of FieldStorage
form = cgi.FieldStorage()

# Get data from fields
if form.getvalue('subject'):
   subject = form.getvalue('subject')
else:
   subject = "Not set"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Radio - Fourth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

テキスト領域データをCGIプログラムに渡す

TEXTAREA要素は、複数行のテキストをCGIプログラムに渡す必要がある場合に使用されます。

以下は、TEXTAREAボックスを持つフォームのHTMLコードの例です-

<form action = "/cgi-bin/textarea.py" method = "post" target = "_blank">
   <textarea name = "textcontent" cols = "40" rows = "4">
      Type your text here...
   </textarea>
   <input type = "submit" value = "Submit"/>
</form>

このコードの結果は次の形式です-

以下は、Webブラウザによって与えられた入力を処理するtextarea.cgiスクリプトです-

#!/usr/bin/python

# Import modules for CGI handling
import cgi, cgitb

# Create instance of FieldStorage
form = cgi.FieldStorage()

# Get data from fields
if form.getvalue('textcontent'):
   text_content = form.getvalue('textcontent')
else:
   text_content = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>";
print "<title>Text Area - Fifth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Entered Text Content is %s</h2>" % text_content
print "</body>"

ドロップダウンボックスデータをCGIプログラムに渡す

ドロップダウンボックスは、使用可能なオプションが多数あるが、1つまたは2つだけが選択される場合に使用されます。

これは、1つのドロップダウンボックスがあるフォームのHTMLコードの例です-

<form action = "/cgi-bin/dropdown.py" method = "post" target = "_blank">
   <select name = "dropdown">
      <option value = "Maths" selected>Maths</option>
      <option value = "Physics">Physics</option>
   </select>
   <input type = "submit" value = "Submit"/>
</form>

このコードの結果は次の形式です-

数学物理学

以下は、Webブラウザーからの入力を処理するdropdown.pyスクリプトです。

#!/usr/bin/python

# Import modules for CGI handling
import cgi, cgitb

# Create instance of FieldStorage
form = cgi.FieldStorage()

# Get data from fields
if form.getvalue('dropdown'):
   subject = form.getvalue('dropdown')
else:
   subject = "Not entered"

print "Content-type:text/html\r\n\r\n"
print "<html>"
print "<head>"
print "<title>Dropdown Box - Sixth CGI Program</title>"
print "</head>"
print "<body>"
print "<h2> Selected Subject is %s</h2>" % subject
print "</body>"
print "</html>"

CGIでのCookieの使用

HTTPプロトコルはステートレスプロトコルです。 商用Webサイトの場合、異なるページ間でセッション情報を維持する必要があります。 たとえば、多くのページを完了すると、1人のユーザー登録が終了します。 すべてのWebページにわたってユーザーのセッション情報を維持する方法は？

多くの場合、Cookieの使用は、ユーザーの利便性やサイトの統計情報を改善するために必要な設定、購入、手数料、その他の情報を記憶および追跡する最も効率的な方法です。

使い方？

サーバーは、Cookieの形式で訪問者のブラウザにデータを送信します。 ブラウザはCookieを受け入れる場合があります。 存在する場合、訪問者のハードドライブにプレーンテキストレコードとして保存されます。 これで、訪問者がサイトの別のページに到達すると、Cookieを取得できます。 取得されると、サーバーは保存された内容を認識/記憶します。

クッキーは5つの可変長フィールドのプレーンテキストデータレコードです-

• 有効期限-Cookieの有効期限が切れる日付。 これが空白の場合、訪問者がブラウザを終了すると、Cookieは期限切れになります。
• ドメイン-サイトのドメイン名。
• Path -Cookieを設定するディレクトリまたはWebページへのパス。 任意のディレクトリまたはページからCookieを取得する場合、これは空白になる場合があります。
• Secure -このフィールドに「secure」という単語が含まれている場合、Cookieはセキュアサーバーでのみ取得できます。 このフィールドが空白の場合、そのような制限はありません。
• 名前=値-Cookieはキーと値のペアの形式で設定および取得されます。

クッキーを設定する

クッキーをブラウザに送信するのは非常に簡単です。 これらのCookieは、HTTPヘッダーとともにコンテンツタイプフィールドに送信されます。 ユーザーIDとパスワードをCookieとして設定するとします。 クッキーの設定は次のように行われます-

#!/usr/bin/python
print "Set-Cookie:UserID = XYZ;\r\n"
print "Set-Cookie:Password = XYZ123;\r\n"
print "Set-Cookie:Expires = Tuesday, 31-Dec-2007 23:12:40 GMT;\r\n"
print "Set-Cookie:Domain = www.finddevguides.com;\r\n"
print "Set-Cookie:Path =/perl;\n"
print "Content-type:text/html\r\n\r\n"
...........Rest of the HTML Content....

この例から、Cookieの設定方法を理解している必要があります。 Set-Cookie HTTPヘッダーを使用して、Cookieを設定します。

Expires、Domain、PathなどのCookie属性を設定することはオプションです。 マジックライン "Content-type：text/html \ r \ n \ r \ n を送信する前にCookieが設定されていることは注目に値します。

Cookieを取得する

設定されたすべてのCookieを取得するのは非常に簡単です。 クッキーはCGI環境変数HTTP_COOKIEに格納されており、次の形式になります-

key1 = value1;key2 = value2;key3 = value3....

Cookieを取得する方法の例を次に示します。

#!/usr/bin/python

# Import modules for CGI handling
from os import environ
import cgi, cgitb

if environ.has_key('HTTP_COOKIE'):
   for cookie in map(strip, split(environ['HTTP_COOKIE'], ';')):
      (key, value ) = split(cookie, '=');
      if key == "UserID":
         user_id = value

      if key == "Password":
         password = value

print "User ID  = %s" % user_id
print "Password = %s" % password

これにより、上記のスクリプトで設定されたCookieに対して次の結果が生成されます-

User ID = XYZ
Password = XYZ123

ファイルアップロードの例

ファイルをアップロードするには、HTMLフォームのenctype属性を multipart/form-data に設定する必要があります。 ファイルタイプの入力タグは、「参照」ボタンを作成します。

<html>
   <body>
      <form enctype = "multipart/form-data" action = "save_file.py" method = "post">
      <p>File: <input type = "file" name = "filename"/></p>
      <p><input type = "submit" value = "Upload"/></p>
      </form>
   </body>
</html>

このコードの結果は次の形式です-

ファイル：

上記の例は、サーバーにファイルをアップロードするユーザーを保存するために意図的に無効にされていますが、サーバーで上記のコードを試すことができます。

ファイルのアップロードを処理するスクリプト save_file.py を次に示します-

#!/usr/bin/python

import cgi, os
import cgitb; cgitb.enable()

form = cgi.FieldStorage()

# Get filename here.
fileitem = form['filename']

# Test if the file was uploaded
if fileitem.filename:
   # strip leading path from file name to avoid
   # directory traversal attacks
   fn = os.path.basename(fileitem.filename)
   open('/tmp/' + fn, 'wb').write(fileitem.file.read())

   message = 'The file "' + fn + '" was uploaded successfully'

else:
   message = 'No file was uploaded'

print """\
Content-Type: text/html\n
<html>
   <body>
      <p>%s</p>
   </body>
</html>
""" % (message,)

Unix/Linuxで上記のスクリプトを実行する場合、次のようにファイル区切り文字を置き換えるように注意する必要があります。そうしないと、Windowsマシンでopen（）ステートメントの上で問題なく動作します。

fn = os.path.basename(fileitem.filename.replace("\\", "/" ))

「ファイルのダウンロード」ダイアログボックスを上げる方法は？

ユーザーがリンクをクリックすると、実際のコンテンツを表示する代わりに「ファイルのダウンロード」ダイアログボックスがポップアップするオプションを提供したい場合があります。 これは非常に簡単で、HTTPヘッダーを使用して実現できます。 このHTTPヘッダーは、前のセクションで説明したヘッダーとは異なります。

たとえば、特定のリンクから FileName ファイルをダウンロード可能にする場合、その構文は次のとおりです-

#!/usr/bin/python

# HTTP Header
print "Content-Type:application/octet-stream; name = \"FileName\"\r\n";
print "Content-Disposition: attachment; filename = \"FileName\"\r\n\n";

# Actual File Content will go here.
fo = open("foo.txt", "rb")

str = fo.read();
print str

# Close opend file
fo.close()

このチュートリアルをお楽しみください。 はいの場合は、link：/about/contact_us [お問い合わせ]からフィードバックを送ってください。

Python 3-MySQLデータベースアクセス

データベースインターフェイスのPython標準は、Python DB-APIです。 ほとんどのPythonデータベースインターフェイスは、この標準に準拠しています。

アプリケーションに適したデータベースを選択できます。 Python Database APIは、次のような幅広いデータベースサーバーをサポートしています-

• ガドフライ
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• オラクル
• Sybase
• SQLite

利用可能なPythonデータベースインターフェースのリストを以下に示します-https://wiki.python.org/moin/DatabaseInterfaces[Python Database Interfaces and APIs]。 アクセスする必要のあるデータベースごとに個別のDB APIモジュールをダウンロードする必要があります。 たとえば、MySQLデータベースだけでなくOracleデータベースにもアクセスする必要がある場合、OracleとMySQLデータベースモジュールの両方をダウンロードする必要があります。

DB APIは、可能な限りPythonの構造と構文を使用してデータベースを操作するための最小限の標準を提供します。 このAPIには以下が含まれます-

• APIモジュールのインポート。
• データベースとの接続を取得します。
• SQLステートメントとストアドプロシージャの発行。
• 接続を閉じる

PythonにはSQLiteの組み込みサポートがあります。 このセクションでは、MySQLを使用してすべての概念を学習します。 MySQLとの一般的なインターフェイスであるMySQLdbモジュールは、Python 3と互換性がありません。 代わりに、http：//www.pymysql.org/[PyMySQL]モジュールを使用します。

PyMySQLとは何ですか？

PyMySQLは、PythonからMySQLデータベースサーバーに接続するためのインターフェイスです。 Python Database API v2.0を実装し、純粋なPython MySQLクライアントライブラリが含まれています。 PyMySQLの目標は、MySQLdbのドロップイン代替物になることです。

PyMySQLをインストールする方法は？

さらに先に進む前に、マシンにPyMySQLがインストールされていることを確認してください。 Pythonスクリプトに次を入力して実行するだけです-

#!/usr/bin/python3

import pymysql

それは次の結果を生成する場合、それはMySQLdbモジュールがインストールされていないことを意味します-

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      Import pymysql
ImportError: No module named pymysql

最後の安定版リリースはPyPIで利用でき、pipでインストールできます-

pip install pymysql

別の方法（例： pipが利用できない場合）、tarballはhttps://github.com/PyMySQL/PyMySQL[GitHub]からダウンロードでき、次のようにSetuptoolsでインストールできます-

$ # X.X is the desired pymysql version (e.g. 0.5 or 0.6).
$ curl -L https://github.com/PyMySQL/PyMySQL/tarball/pymysql-X.X | tar xz
$ cd PyMySQL*
$ python setup.py install
$ # The folder PyMySQL* can be safely removed now.

注意-上記のモジュールをインストールするためのルート権限があることを確認してください。

データベース接続

MySQLデータベースに接続する前に、次の点を確認してください-

• データベースTESTDBを作成しました。
• TESTDBにテーブルEMPLOYEEを作成しました。
• このテーブルには、FIRST_NAME、LAST_NAME、AGE、SEX、およびINCOMEフィールドがあります。
• ユーザーID「testuser」とパスワード「test123」は、TESTDBにアクセスするように設定されています。
• PythonモジュールPyMySQLがマシンに適切にインストールされています。
• リンクを理解するためにMySQLチュートリアルを完了しました：/mysql/index [MySQL Basics。]

例

以下は、MySQLデータベース「TESTDB」との接続例です-

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# execute SQL query using execute() method.
cursor.execute("SELECT VERSION()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print ("Database version : %s " % data)

# disconnect from server
db.close()

このスクリプトを実行すると、次の結果が生成されます。

Database version : 5.5.20-log

データソースとの接続が確立されると、接続オブジェクトが返され、さらに使用するために db に保存されます。それ以外の場合、 db はNoneに設定されます。 次に、 db オブジェクトを使用して cursor オブジェクトを作成し、これを使用してSQLクエリを実行します。 最後に、出てくる前に、データベース接続が閉じられ、リソースが解放されるようにします。

データベーステーブルの作成

データベース接続が確立されると、作成されたカーソルの execute メソッドを使用して、データベーステーブルにテーブルまたはレコードを作成する準備ができました。

例

データベーステーブルEMPLOYEEを作成しましょう-

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Drop table if it already exist using execute() method.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

# Create table as per requirement
sql = """CREATE TABLE EMPLOYEE (
   FIRST_NAME  CHAR(20) NOT NULL,
   LAST_NAME  CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT )"""

cursor.execute(sql)

# disconnect from server
db.close()

INSERT操作

データベーステーブルにレコードを作成する場合は、INSERT操作が必要です。

例

次の例では、SQL _INSERT_ステートメントを実行して、EMPLOYEEテーブルにレコードを作成します-

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
   LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

上記の例は、SQLクエリを動的に作成するために次のように記述できます-

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
   LAST_NAME, AGE, SEX, INCOME) \
   VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
   ('Mac', 'Mohan', 20, 'M', 2000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

例

次のコードセグメントは、パラメータを直接渡すことができる実行の別の形式です-

..................................
user_id = "test123"
password = "password"

con.execute('insert into Login values("%s", "%s")' % \
             (user_id, password))
..................................

読み取り操作

任意のデータベースに対するREAD操作は、データベースからいくつかの有用な情報を取得することを意味します。

データベース接続が確立されると、このデータベースにクエリを実行する準備が整います。 * fetchone（）メソッドを使用して単一のレコードをフェッチするか、 fetchall（）*メソッドを使用してデータベーステーブルから複数の値をフェッチできます。

• * fetchone（）*-クエリ結果セットの次の行をフェッチします。 結果セットは、カーソルオブジェクトを使用してテーブルを照会するときに返されるオブジェクトです。
• * fetchall（）*-結果セットのすべての行をフェッチします。 結果セットからすでにいくつかの行が抽出されている場合、取得します 結果セットの残りの行。
• rowcount -これは読み取り専用の属性であり、execute（）メソッドの影響を受けた行の数を返します。

例

次の手順では、給与が1000を超えるEMPLOYEEテーブルのすべてのレコードを照会します-

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to INSERT a record into the database.
sql = "SELECT * FROM EMPLOYEE \
      WHERE INCOME > '%d'" % (1000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Fetch all the rows in a list of lists.
   results = cursor.fetchall()
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
      # Now print fetched result
      print ("fname = %s,lname = %s,age = %d,sex = %s,income = %d" % \
         (fname, lname, age, sex, income ))
except:
   print ("Error: unable to fetch data")

# disconnect from server
db.close()

出力

これは、次の結果を生成します-

fname = Mac, lname = Mohan, age = 20, sex = M, income = 2000

更新操作

データベースでのUPDATE操作とは、データベースですでに使用可能な1つ以上のレコードを更新することです。

次の手順は、SEXが 'M' であるすべてのレコードを更新します。 ここでは、すべての男性の年齢を1年増やします。

例

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to UPDATE required records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
                          WHERE SEX = '%c'" % ('M')
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

削除操作

データベースから一部のレコードを削除する場合は、DELETE操作が必要です。 以下は、年齢が20を超える従業員からすべてのレコードを削除する手順です。

例

#!/usr/bin/python3

import pymysql

# Open database connection
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

トランザクションの実行

トランザクションは、データの一貫性を保証するメカニズムです。 トランザクションには、次の4つのプロパティがあります-

• Atomicity -トランザクションが完了するか、まったく何も起こりません。
• 一貫性-トランザクションは一貫した状態で開始し、システムを一貫した状態のままにする必要があります。
• 分離-トランザクションの中間結果は、現在のトランザクションの外部では見えません。
• 耐久性-トランザクションがコミットされると、システム障害が発生した後でも効果は持続します。

Python DB API 2.0は、トランザクションを_commit_または_rollback_する2つのメソッドを提供します。

例

トランザクションを実装する方法はすでに知っています。 ここに同様の例があります-

# Prepare SQL query to DELETE required records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

コミット操作

コミットは、変更をファイナライズするためにデータベースに緑のシグナルを与える操作です。この操作の後、変更を元に戻すことはできません。

*commit* メソッドを呼び出す簡単な例を次に示します。

db.commit()

ロールバック操作

1つ以上の変更に満足せず、それらの変更を完全に元に戻したい場合は、* rollback（）*メソッドを使用します。

• rollback（）*メソッドを呼び出す簡単な例を次に示します。

db.rollback()

データベースの切断

データベース接続を切断するには、close（）メソッドを使用します。

db.close()

データベースへの接続がclose（）メソッドを使用してユーザーによって閉じられた場合、未処理のトランザクションはすべてDBによってロールバックされます。 ただし、DBの下位レベルの実装の詳細に依存する代わりに、アプリケーションで明示的にcommitまたはrollbackを呼び出す方が適切です。

エラー処理

エラーには多くの原因があります。 いくつかの例は、実行されたSQLステートメントの構文エラー、接続障害、または既にキャンセルまたは終了したステートメントハンドルのフェッチメソッドの呼び出しです。

DB APIは、各データベースモジュールに存在する必要があるエラーの数を定義します。 次の表に、これらの例外をリストします。

Sr.No.	Exception & Description
1	Warning 致命的でない問題に使用されます。 StandardErrorをサブクラス化する必要があります。
2	Error エラーの基本クラス。 StandardErrorをサブクラス化する必要があります。
3	InterfaceError データベース自体ではなく、データベースモジュールのエラーに使用されます。 エラーをサブクラス化する必要があります。
4	DatabaseError データベースのエラーに使用されます。 エラーをサブクラス化する必要があります。
5	DataError データのエラーを参照するDatabaseErrorのサブクラス。
6	OperationalError データベースへの接続が失われるなどのエラーを参照するDatabaseErrorのサブクラス。 これらのエラーは通常、Pythonスクリプターの制御外です。
7	IntegrityError 一意性制約や外部キーなど、リレーショナルの整合性を損なう状況のDatabaseErrorのサブクラス。
8	InternalError カーソルがアクティブでなくなったなど、データベースモジュール内部のエラーを参照するDatabaseErrorのサブクラス。
9	ProgrammingError DatabaseErrorのサブクラス。不正なテーブル名などのエラーや、安全に非難できるものを参照します。
10	NotSupportedError サポートされていない機能を呼び出そうとすることを指すDatabaseErrorのサブクラス。

Pythonスクリプトはこれらのエラーを処理する必要がありますが、上記の例外を使用する前に、MySQLdbがその例外をサポートしていることを確認してください。 DB API 2.0仕様を読むと、それらに関する詳細情報を取得できます。

Python 3-ネットワークプログラミング

Pythonは、ネットワークサービスへの2つのレベルのアクセスを提供します。 低レベルでは、基盤となるオペレーティングシステムの基本的なソケットサポートにアクセスできます。これにより、接続指向プロトコルとコネクションレスプロトコルの両方のクライアントとサーバーを実装できます。

Pythonには、FTP、HTTPなどの特定のアプリケーションレベルのネットワークプロトコルへの高レベルのアクセスを提供するライブラリもあります。

この章では、ネットワークで最も有名な概念-ソケットプログラミングについて理解します。

ソケットとは何ですか？

ソケットは、双方向通信チャネルのエンドポイントです。 ソケットは、プロセス内、同じマシン上のプロセス間、または異なる大陸のプロセス間で通信できます。

ソケットは、Unixドメインソケット、TCP、UDPなど、さまざまなチャネルタイプで実装できます。 _socket_ライブラリは、一般的なトランスポートを処理するための特定のクラスと、残りを処理するための汎用インターフェイスを提供します。

ソケットには独自の語彙があります-

Sr.No.	Term & Description
1	domain トランスポートメカニズムとして使用されるプロトコルファミリ。 これらの値は、AF_INET、PF_INET、PF_UNIX、PF_X25などの定数です。
2	type 2つのエンドポイント間の通信のタイプ。通常、接続指向プロトコルの場合はSOCK_STREAM、コネクションレスプロトコルの場合はSOCK_DGRAM。
3	protocol 通常、これはドメインおよびタイプ内のプロトコルのバリアントを識別するために使用できます。
4	hostname ネットワークインターフェイスの識別子- 文字列。ホスト名、ドット区切りのアドレス、またはコロン（および場合によってはドット）表記のIPV6アドレスを指定できます INADDR_BROADCASTアドレスを指定する文字列「<broadcast>」。 INADDR_ANYを指定する長さゼロの文字列、または *ホストバイト順のバイナリアドレスとして解釈される整数。
5	port* 各サーバーは、1つ以上のポートで呼び出しているクライアントをリッスンします。 ポートは、Fixnumポート番号、ポート番号を含む文字列、またはサービスの名前です。

ソケットモジュール

ソケットを作成するには、一般的な構文を持つソケットモジュールで利用可能な_socket.socket（）_関数を使用する必要があります-

s = socket.socket (socket_family, socket_type, protocol = 0)

ここにパラメータの説明があります-

• socket_family -これは、前述のようにAF_UNIXまたはAF_INETのいずれかです。
• socket_type -これはSOCK_STREAMまたはSOCK_DGRAMのいずれかです。
• protocol -これは通常省略され、デフォルトは0です。

_socket_オブジェクトを取得したら、必要な関数を使用してクライアントまたはサーバープログラムを作成できます。 以下は、必要な機能のリストです-

サーバーソケットメソッド

Sr.No.	Method & Description
1	s.bind() このメソッドは、アドレス（ホスト名、ポート番号のペア）をソケットにバインドします。
2	s.listen() このメソッドは、TCPリスナーをセットアップして開始します。
3	s.accept() これは、TCPクライアント接続を受動的に受け入れ、接続が到着するまで待機します（ブロック）。

クライアントソケットメソッド

Sr.No.	Method & Description
1	s.connect() このメソッドは、TCPサーバー接続をアクティブに開始します。

一般的なソケットメソッド

Sr.No.	Method & Description
1	s.recv() このメソッドはTCPメッセージを受信します
2	s.send() このメソッドはTCPメッセージを送信します
3	s.recvfrom() このメソッドはUDPメッセージを受信します
4	s.sendto() このメソッドはUDPメッセージを送信します
5	s.close() このメソッドはソケットを閉じます
6	socket.gethostname() ホスト名を返します。

シンプルなサーバー

インターネットサーバーを作成するには、ソケットモジュールで使用可能な socket 関数を使用してソケットオブジェクトを作成します。 次に、ソケットオブジェクトを使用して他の関数を呼び出し、ソケットサーバーをセットアップします。

次に、* bind（hostname、port）*関数を呼び出して、指定されたホスト上のサービスの_port_を指定します。

次に、返されたオブジェクトの_accept_メソッドを呼び出します。 このメソッドは、クライアントが指定したポートに接続するまで待機し、そのクライアントへの接続を表す_connection_オブジェクトを返します。

#!/usr/bin/python3           # This is server.py file
import socket

# create a socket object
serversocket = socket.socket(
            socket.AF_INET, socket.SOCK_STREAM)

# get local machine name
host = socket.gethostname()

port = 9999

# bind to the port
serversocket.bind((host, port))

# queue up to 5 requests
serversocket.listen(5)

while True:
   # establish a connection
   clientsocket,addr = serversocket.accept()

   print("Got a connection from %s" % str(addr))

   msg = 'Thank you for connecting'+ "\r\n"
   clientsocket.send(msg.encode('ascii'))
   clientsocket.close()

シンプルなクライアント

特定のポート12345と特定のホストへの接続を開く、非常に単純なクライアントプログラムを作成してみましょう。 Pythonの_socket_モジュール関数を使用してソケットクライアントを作成するのは非常に簡単です。

• socket.connect（hosname、port）*は、_port_上の_hostname_へのTCP接続を開きます。 ソケットを開いたら、IOオブジェクトのようにソケットから読み取ることができます。 完了したら、ファイルを閉じるのと同じように忘れずに閉じてください。

例

次のコードは、特定のホストとポートに接続し、ソケットから利用可能なデータを読み取り、終了する非常に単純なクライアントです-

#!/usr/bin/python3           # This is client.py file

import socket

# create a socket object
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# get local machine name
host = socket.gethostname()

port = 9999

# connection to hostname on the port.
s.connect((host, port))

# Receive no more than 1024 bytes
msg = s.recv(1024)

s.close()
print (msg.decode('ascii'))

次に、このserver.pyをバックグラウンドで実行し、上記のclient.pyを実行して結果を確認します。

# Following would start a server in background.
$ python server.py &

# Once server is started run client as follows:
$ python client.py

出力

これは、次の結果を生成します-

on server terminal
Got a connection from ('192.168.1.10', 3747)
On client terminal
Thank you for connecting

Pythonインターネットモジュール

Pythonネットワーク/インターネットプログラミングの重要なモジュールのリストを以下に示します-

Protocol	Common function	Port No	Python module
HTTP	Web pages	80	httplib, urllib, xmlrpclib
NNTP	Usenet news	119	nntplib
FTP	File transfers	20	ftplib, urllib
SMTP	Sending email	25	smtplib
POP3	Fetching email	110	poplib
IMAP4	Fetching email	143	imaplib
Telnet	Command lines	23	telnetlib
Gopher	Document transfers	70	gopherlib, urllib

FTP、SMTP、POP、およびIMAPプロトコルを使用するには、上記のすべてのライブラリを確認してください。

さらに読む

これは、ソケットプログラミングのクイックスタートでした。 それは広大なテーマです。 詳細を見つけるには、次のリンクを参照することをお勧めします-

• link：/unix_sockets/index [Unixソケットプログラミング]。
• Python Socket Library and Modules。

Python 3-SMTPを使用してメールを送信する

SMTP（Simple Mail Transfer Protocol）は、メールサーバー間の電子メールの送信とルーティングを処理するプロトコルです。

Pythonは smtplib モジュールを提供します。このモジュールは、SMTPまたはESMTPリスナーデーモンを備えた任意のインターネットマシンにメールを送信するために使用できるSMTPクライアントセッションオブジェクトを定義します。

これは、後で電子メールの送信に使用できる1つのSMTPオブジェクトを作成する簡単な構文です-

import smtplib

smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

ここにパラメータの詳細があります-

• host -これは、SMTPサーバーを実行しているホストです。 ホストのIPアドレスまたはfinddevguides.comのようなドメイン名を指定できます。 これはオプションの引数です。
• port -_host_引数を指定する場合、SMTPサーバーがリッスンしているポートを指定する必要があります。 通常、このポートは25です。
• local_hostname -SMTPサーバーがローカルマシンで実行されている場合、_localhost_オプションのみを指定できます。

SMTPオブジェクトには、 sendmail と呼ばれるインスタンスメソッドがあります。これは、通常、メッセージのメール送信作業を行うために使用されます。 それは3つのパラメータを取ります-

• sender-送信者のアドレスを含む文字列。
• receivers-文字列のリスト、各受信者に1つ。
• message-さまざまなRFCで指定された形式の文字列としてのメッセージ。

例

Pythonスクリプトを使用して1つの電子メールを送信する簡単な方法を次に示します。 一度試してください-

#!/usr/bin/python3

import smtplib

sender = '[email protected]'
receivers = ['[email protected]']

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

ここでは、ヘッダーを正しくフォーマットするよう注意しながら、三重引用符を使用して基本的な電子メールをメッセージに配置しました。 電子メールには、 From 、 To 、および Subject ヘッダーが必要です。これらのヘッダーは、電子メールの本文から空白行で区切られています。

メールを送信するには、_smtpObj_を使用してローカルマシンのSMTPサーバーに接続します。 次に、_sendmail_メソッドをメッセージ、送信元アドレス、および宛先アドレスとともにパラメーターとして使用します（送信元アドレスと送信先アドレスは電子メール自体の中にありますが、これらは常にメールのルーティングに使用されるわけではありません）。

ローカルマシンでSMTPサーバーを実行していない場合は、_smtplib_クライアントを使用してリモートSMTPサーバーと通信できます。 ウェブメールサービス（GmailやYahoo!など）を使用していない場合 メール）、あなたの電子メールプロバイダーは、次のように、あなたがそれらを提供できる送信メールサーバーの詳細を提供している必要があります-

mail = smtplib.SMTP('smtp.gmail.com', 587)

Pythonを使用してHTML電子メールを送信する

Pythonを使用してテキストメッセージを送信すると、すべてのコンテンツが単純なテキストとして扱われます。 テキストメッセージにHTMLタグを含めても、単純なテキストとして表示され、HTML構文に従ってHTMLタグはフォーマットされません。 ただし、Pythonには、HTMLメッセージを実際のHTMLメッセージとして送信するオプションがあります。

電子メールメッセージを送信するときに、MIMEバージョン、コンテンツタイプ、および文字セットを指定して、HTML電子メールを送信できます。

例

以下は、HTMLコンテンツを電子メールとして送信する例です。 一度試してください-

#!/usr/bin/python3

import smtplib

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP HTML e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

添付ファイルを電子メールとして送信する

混合コンテンツを含む電子メールを送信するには、 Content-type ヘッダーを multipart/mixed に設定する必要があります。 次に、テキストと添付セクションを boundaries 内で指定できます。

境界は2つのハイフンで始まり、その後に一意の番号が続きます。この番号は、電子メールのメッセージ部分には表示されません。 電子メールの最終セクションを示す最終境界も、2つのハイフンで終わる必要があります。

添付ファイルは、* pack（ "m"）*関数でエンコードしてから、送信前にBase 64エンコードにする必要があります。

例

以下は、ファイル /tmp/test.txt を添付ファイルとして送信する例です。 一度試してください-

#!/usr/bin/python3

import smtplib
import base64

filename = "/tmp/test.txt"

# Read a file and encode it into base64 format
fo = open(filename, "rb")
filecontent = fo.read()
encodedcontent = base64.b64encode(filecontent)  # base64

sender = '[email protected]'
reciever = '[email protected]'

marker = "AUNIQUEMARKER"

body ="""
This is a test email to send an attachement.
"""
# Define the main headers.
part1 = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=%s
--%s
""" % (marker, marker)

# Define the message action
part2 = """Content-Type: text/plain
Content-Transfer-Encoding:8bit

%s
--%s
""" % (body,marker)

# Define the attachment section
part3 = """Content-Type: multipart/mixed; name=\"%s\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename=%s

%s
--%s--
""" %(filename, filename, encodedcontent, marker)
message = part1 + part2 + part3

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, reciever, message)
   print "Successfully sent email"
except Exception:
   print ("Error: unable to send email")

Python 3-マルチスレッドプログラミング

複数のスレッドを実行すると、複数の異なるプログラムを同時に実行することに似ていますが、次の利点があります-

• プロセス内の複数のスレッドはメインスレッドと同じデータ空間を共有するため、別々のプロセスである場合よりも簡単に情報を共有したり、相互に通信したりできます。
• スレッドはライトウェイトプロセスと呼ばれることもあり、多くのメモリオーバーヘッドを必要としません。プロセスよりも安価です。

スレッドには、開始、実行シーケンス、および結論があります。 コンテキスト内で現在実行されている場所を追跡する命令ポインターがあります。

• 横取り（中断）することができます。
• 他のスレッドが実行されている間、一時的に保留（スリープとも呼ばれます）できます-これは、譲歩と呼ばれます。

スレッドには2種類あります-

• カーネルスレッド
• ユーザースレッド

カーネルスレッドはオペレーティングシステムの一部ですが、ユーザー空間のスレッドはカーネルに実装されていません。

Python3のスレッドの使用をサポートする2つのモジュールがあります-

• _糸
• スレッディング

スレッドモジュールはかなり長い間「非推奨」になっています。 代わりに、スレッドモジュールを使用することをお勧めします。 したがって、Python 3では、モジュール「スレッド」は使用できなくなりました。 ただし、Python3の後方互換性のために「_thread」に名前が変更されました。

新しいスレッドの開始

別のスレッドを生成するには、_thread_モジュールで利用可能な次のメソッドを呼び出す必要があります-

_thread.start_new_thread ( function, args[, kwargs] )

このメソッド呼び出しにより、LinuxとWindowsの両方で新しいスレッドを高速かつ効率的に作成できます。

メソッド呼び出しはすぐに戻り、子スレッドが開始され、_args_の渡されたリストで関数を呼び出します。 関数が戻ると、スレッドは終了します。

ここで、_args_は引数のタプルです。引数を渡さずに関数を呼び出すには、空のタプルを使用します。 _kwargs_は、キーワード引数のオプションの辞書です。

例

#!/usr/bin/python3

import _thread
import time

# Define a function for the thread
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print ("%s: %s" % ( threadName, time.ctime(time.time()) ))

# Create two threads as follows
try:
   _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print ("Error: unable to start thread")

while 1:
   pass

出力

上記のコードが実行されると、次の結果が生成されます-

Thread-1: Fri Feb 19 09:41:39 2016
Thread-2: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:43 2016
Thread-2: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:47 2016
Thread-2: Fri Feb 19 09:41:49 2016
Thread-2: Fri Feb 19 09:41:53 2016

プログラムは無限ループに入ります。 停止するにはctrl-cを押す必要があります

低レベルのスレッド化には非常に効果的ですが、_thread_モジュールは新しいスレッド化モジュールに比べて非常に制限されています。

スレッド化モジュール

Python 2.4に含まれている新しいスレッドモジュールは、前のセクションで説明したスレッドモジュールよりも強力で高レベルなスレッドのサポートを提供します。

_threading_モジュールは_thread_モジュールのすべてのメソッドを公開し、いくつかの追加のメソッドを提供します-

• * threading.activeCount（）*-アクティブなスレッドオブジェクトの数を返します。
• * threading.currentThread（）*-呼び出し元のスレッドコントロール内のスレッドオブジェクトの数を返します。
• * threading.enumerate（）*-現在アクティブなすべてのスレッドオブジェクトのリストを返します。

メソッドに加えて、スレッド化モジュールには、スレッド化を実装する_Thread_クラスがあります。 _Thread_クラスによって提供されるメソッドは次のとおりです-

• * run（）*-run（）メソッドは、スレッドのエントリポイントです。
• * start（）*-start（）メソッドは、runメソッドを呼び出してスレッドを開始します。
• * join（[time]）*-join（）はスレッドが終了するのを待ちます。
• * isAlive（）*-isAlive（）メソッドは、スレッドがまだ実行中かどうかを確認します。
• * getName（）*-getName（）メソッドは、スレッドの名前を返します。
• * setName（）*-setName（）メソッドは、スレッドの名前を設定します。

スレッド化モジュールを使用してスレッドを作成する

スレッドモジュールを使用して新しいスレッドを実装するには、次を行う必要があります-

• _Thread_クラスの新しいサブクラスを定義します。
• _ init（self [、args]）_メソッドをオーバーライドして、引数を追加します。
• 次に、run（self [、args]）メソッドをオーバーライドして、開始時にスレッドが行うべきことを実装します。

新しい_Thread_サブクラスを作成したら、そのインスタンスを作成してから、_start（）_を呼び出して新しいスレッドを開始し、次に_run（）_メソッドを呼び出します。

例

#!/usr/bin/python3

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print ("Starting " + self.name)
      print_time(self.name, self.counter, 5)
      print ("Exiting " + self.name)

def print_time(threadName, delay, counter):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print ("%s: %s" % (threadName, time.ctime(time.time())))
      counter -= 1

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("Exiting Main Thread")

結果

上記のプログラムを実行すると、次の結果が生成されます-

Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:00:21 2016
Thread-2: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:23 2016
Thread-2: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:25 2016
Exiting Thread-1
Thread-2: Fri Feb 19 10:00:26 2016
Thread-2: Fri Feb 19 10:00:28 2016
Thread-2: Fri Feb 19 10:00:30 2016
Exiting Thread-2
Exiting Main Thread

スレッドの同期

Pythonで提供されるスレッドモジュールには、スレッドを同期するための実装が簡単なロックメカニズムが含まれています。 新しいロックを返すには、_Lock（）_メソッドを呼び出して新しいロックを作成します。

新しいロックオブジェクトの_acquire（blocking）_メソッドを使用して、スレッドを強制的に同期的に実行します。 オプションの_blocking_パラメーターを使用すると、スレッドがロックの取得を待機するかどうかを制御できます。

_blocking_が0に設定されている場合、スレッドは、ロックを取得できない場合はすぐに0の値を返し、ロックが取得された場合は1を返します。 ブロックが1に設定されている場合、スレッドはブロックし、ロックが解除されるのを待ちます。

新しいロックオブジェクトの_release（）_メソッドは、不要になったときにロックを解除するために使用されます。

例

#!/usr/bin/python3

import threading
import time

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print ("Starting " + self.name)
      # Get lock to synchronize threads
      threadLock.acquire()
      print_time(self.name, self.counter, 3)
      # Free lock to release next thread
      threadLock.release()

def print_time(threadName, delay, counter):
   while counter:
      time.sleep(delay)
      print ("%s: %s" % (threadName, time.ctime(time.time())))
      counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
   t.join()
print ("Exiting Main Thread")

出力

上記のコードが実行されると、次の結果が生成されます-

Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:04:14 2016
Thread-1: Fri Feb 19 10:04:15 2016
Thread-1: Fri Feb 19 10:04:16 2016
Thread-2: Fri Feb 19 10:04:18 2016
Thread-2: Fri Feb 19 10:04:20 2016
Thread-2: Fri Feb 19 10:04:22 2016
Exiting Main Thread

マルチスレッドプライオリティキュー

_Queue_モジュールを使用すると、特定の数のアイテムを保持できる新しいキューオブジェクトを作成できます。 キューを制御するには、次の方法があります-

• * get（）*-get（）は、キューからアイテムを削除して返します。
• * put（）*-putは、アイテムをキューに追加します。
• * qsize（）*-qsize（）は、現在キューにあるアイテムの数を返します。
• * empty（）*-empty（）は、キューが空の場合にTrueを返します。それ以外の場合、False。
• * full（）*-キューがいっぱいの場合、full（）はTrueを返します。それ以外の場合、False。

例

#!/usr/bin/python3

import queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, q):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.q = q
   def run(self):
      print ("Starting " + self.name)
      process_data(self.name, self.q)
      print ("Exiting " + self.name)

def process_data(threadName, q):
   while not exitFlag:
      queueLock.acquire()
      if not workQueue.empty():
         data = q.get()
         queueLock.release()
         print ("%s processing %s" % (threadName, data))
      else:
         queueLock.release()
         time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

# Create new threads
for tName in threadList:
   thread = myThread(threadID, tName, workQueue)
   thread.start()
   threads.append(thread)
   threadID += 1

# Fill the queue
queueLock.acquire()
for word in nameList:
   workQueue.put(word)
queueLock.release()

# Wait for queue to empty
while not workQueue.empty():
   pass

# Notify threads it's time to exit
exitFlag = 1

# Wait for all threads to complete
for t in threads:
   t.join()
print ("Exiting Main Thread")

出力

上記のコードが実行されると、次の結果が生成されます-

Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

Python 3-XML処理

XMLは、オペレーティングシステムや開発言語に関係なく、プログラマが他のアプリケーションで読み取れるアプリケーションを開発できる、移植可能なオープンソース言語です。

XMLとは何ですか？

拡張マークアップ言語（XML）は、HTMLやSGMLによく似たマークアップ言語です。 これは、World Wide Web Consortiumによって推奨されており、オープンスタンダードとして利用できます。

XMLは、SQLベースのバックボーンを必要とせずに、少量から中量のデータを追跡するのに非常に役立ちます。

XMLパーサーのアーキテクチャとAPI

Python標準ライブラリは、XMLを操作するための最小限で便利なインターフェイスのセットを提供します。

XMLデータに対して最も基本的で広く使用されている2つのAPIは、SAXおよびDOMインターフェースです。

• * Simple API for XML（SAX）*-ここでは、目的のイベントのコールバックを登録し、パーサーにドキュメントを処理させます。 これは、ドキュメントが大きい場合やメモリに制限がある場合に便利です。ディスクからファイルを読み取るときにファイルを解析し、ファイル全体がメモリに保存されることはありません。
• *ドキュメントオブジェクトモデル（DOM）API *-これは、XMLドキュメントのすべての機能を表すためにファイル全体がメモリに読み込まれ、階層（ツリーベース）形式で格納されるWorld Wide Web Consortiumの推奨事項です。

SAXは、大きなファイルを扱う場合、DOMほど速く情報を処理できないことは明らかです。 一方、DOMを排他的に使用すると、特に多くの小さなファイルで使用されている場合、リソースを本当に殺す可能性があります。

SAXは読み取り専用ですが、DOMはXMLファイルの変更を許可します。 これら2つの異なるAPIは文字通り互いに補完するため、大規模プロジェクトで両方を使用できない理由はありません。

すべてのXMLコードの例について、単純なXMLファイル_movies.xml_を入力として使用してみましょう-

<collection shelf = "New Arrivals">
<movie title = "Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title = "Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title = "Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title = "Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

SAX APIを使用したXMLの解析

SAXは、イベント駆動型XML解析の標準インターフェイスです。 通常、SAXでXMLを解析するには、xml.sax.ContentHandlerをサブクラス化して独自のContentHandlerを作成する必要があります。

_ContentHandler_は、XMLのフレーバーの特定のタグと属性を処理します。 ContentHandlerオブジェクトは、さまざまな解析イベントを処理するメソッドを提供します。 所有するパーサーは、XMLファイルを解析するときにContentHandlerメソッドを呼び出します。

メソッド_startDocument_および_endDocument_は、XMLファイルの開始時と終了時に呼び出されます。 メソッド_characters（text）_には、パラメータテキストを介してXMLファイルの文字データが渡されます。

ContentHandlerは、各要素の開始時と終了時に呼び出されます。 パーサーがネームスペースモードでない場合、メソッド_startElement（tag、attributes）_および_endElement（tag）_が呼び出されます。それ以外の場合、対応するメソッド_startElementNS_および_endElementNS_が呼び出されます。 ここで、タグは要素タグであり、属性は属性オブジェクトです。

ここに進む前に理解する他の重要な方法があります-

make_parserメソッド

次のメソッドは、新しいパーサーオブジェクトを作成して返します。 作成されたパーサーオブジェクトは、システムが検出した最初のパーサータイプになります。

xml.sax.make_parser( [parser_list] )

ここにパラメータの詳細があります-

• parser_list -make_parserメソッドをすべて実装する必要がある、使用するパーサーのリストで構成されるオプションの引数。

解析メソッド

次のメソッドは、SAXパーサーを作成し、それを使用してドキュメントを解析します。

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

ここにパラメータの詳細があります-

• xmlfile -これは、読み取り元のXMLファイルの名前です。
• contenthandler -これはContentHandlerオブジェクトでなければなりません。
• errorhandler -指定する場合、errorhandlerはSAX ErrorHandlerオブジェクトでなければなりません。

parseStringメソッド

SAXパーサーを作成し、指定された* XML文字列*を解析する方法がもう1つあります。

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

ここにパラメータの詳細があります-

• xmlstring -これは、読み取り元のXML文字列の名前です。
• contenthandler -これはContentHandlerオブジェクトでなければなりません。
• errorhandler -指定する場合、errorhandlerはSAX ErrorHandlerオブジェクトでなければなりません。

例

#!/usr/bin/python3

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print ("*****Movie*****")
         title = attributes["title"]
         print ("Title:", title)

   # Call when an elements ends
   def endElement(self, tag):
      if self.CurrentData == "type":
         print ("Type:", self.type)
      elif self.CurrentData == "format":
         print ("Format:", self.format)
      elif self.CurrentData == "year":
         print ("Year:", self.year)
      elif self.CurrentData == "rating":
         print ("Rating:", self.rating)
      elif self.CurrentData == "stars":
         print ("Stars:", self.stars)
      elif self.CurrentData == "description":
         print ("Description:", self.description)
      self.CurrentData = ""

   # Call when a character is read
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content

if ( __name__ == "__main__"):

   # create an XMLReader
   parser = xml.sax.make_parser()
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )

   parser.parse("movies.xml")

出力

これは、次の結果を生成します-

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

SAX APIドキュメントの詳細については、標準のhttps://docs.python.org/library/xml.saxl[Python SAX API]を参照してください。

DOM APIを使用したXMLの解析

Document Object Model（ "DOM"）は、XMLドキュメントにアクセスして変更するためのWorld Wide Web Consortium（W3C）のクロス言語APIです。

DOMは、ランダムアクセスアプリケーションに非常に役立ちます。 SAXでは、一度に1ビットのドキュメントのみを表示できます。 あるSAX要素を見ている場合、別のSAX要素にはアクセスできません。

XMLドキュメントをすばやくロードし、xml.domモジュールを使用してminidomオブジェクトを作成する最も簡単な方法を次に示します。 minidomオブジェクトは、XMLファイルからDOMツリーをすばやく作成する簡単なパーサーメソッドを提供します。

サンプルフレーズは、minidomオブジェクトのparse（file [、parser]）関数を呼び出して、fileで指定されたXMLファイルをDOMツリーオブジェクトに解析します。

例

#!/usr/bin/python3

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print ("Root element : %s" % collection.getAttribute("shelf"))

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print ("*****Movie*****")
   if movie.hasAttribute("title"):
      print ("Title: %s" % movie.getAttribute("title"))

   type = movie.getElementsByTagName('type')[0]
   print ("Type: %s" % type.childNodes[0].data)
   format = movie.getElementsByTagName('format')[0]
   print ("Format: %s" % format.childNodes[0].data)
   rating = movie.getElementsByTagName('rating')[0]
   print ("Rating: %s" % rating.childNodes[0].data)
   description = movie.getElementsByTagName('description')[0]
   print ("Description: %s" % description.childNodes[0].data)

出力

これは、次の結果を生成します-

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

DOM APIドキュメントの詳細については、標準のhttps://docs.python.org/library/xml.doml[Python DOM APIs]を参照してください。

Python 3-GUIプログラミング（Tkinter）

Pythonは、グラフィカルユーザーインターフェイス（GUI）を開発するためのさまざまなオプションを提供します。 最も重要な機能を以下にリストします。

• Tkinter -Tkinterは、Pythonに付属のTk GUIツールキットへのPythonインターフェイスです。 この章では、このオプションを検討します。
• wxPython -これはwxWidgets GUIツールキット用のオープンソースPythonインターフェイスです。 WxPython https://www.finddevguides.com/wxpython/index [こちら]で完全なチュートリアルを見つけることができます。
• PyQt -これは、一般的なクロスプラットフォームQt GUIライブラリのPythonインターフェイスでもあります。 finddevguidesには、PyQt https://www.finddevguides.com/pyqt/index [こちら]に非常に優れたチュートリアルがあります。
• JPython -JPythonはJava用のPythonポートであり、Pythonスクリプトがローカルマシンhttp://www.jython.orgのJavaクラスライブラリにシームレスにアクセスできるようにします。

他にも多くのインターフェースが利用可能ですが、それらはネット上で見つけることができます。

Tkinterプログラミング

TkinterはPythonの標準GUIライブラリです。 PythonをTkinterと組み合わせると、GUIアプリケーションをすばやく簡単に作成できます。 Tkinterは、Tk GUIツールキットへの強力なオブジェクト指向インターフェースを提供します。

Tkinterを使用してGUIアプリケーションを作成するのは簡単です。 あなたがする必要があるのは、次の手順を実行することです-

• _Tkinter_モジュールをインポートします。
• GUIアプリケーションのメインウィンドウを作成します。
• 上記のウィジェットの1つ以上をGUIアプリケーションに追加します。
• メインイベントループに入り、ユーザーによってトリガーされた各イベントに対してアクションを実行します。

例

#!/usr/bin/python3

import tkinter # note that module name has changed from Tkinter in Python 2 to tkinter in Python 3
top = tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()

これは、次のウィンドウを作成します-

TK Window

Tkinterウィジェット

Tkinterは、GUIアプリケーションで使用されるボタン、ラベル、テキストボックスなどのさまざまなコントロールを提供します。 これらのコントロールは一般にウィジェットと呼ばれます。

Tkinterには現在15種類のウィジェットがあります。 これらのウィジェットと、次の表に簡単な説明を示します-

Sr.No.	Operator & Description
1	Button Buttonウィジェットは、アプリケーションでボタンを表示するために使用されます。
2	Canvas Canvasウィジェットは、アプリケーションで線、楕円、多角形、長方形などの形状を描くために使用されます。
3	Checkbutton Checkbuttonウィジェットは、多くのオプションをチェックボックスとして表示するために使用されます。 ユーザーは一度に複数のオプションを選択できます。
4	Entry 入力ウィジェットは、ユーザーから値を受け取るための単一行のテキストフィールドを表示するために使用されます。
5	Frame フレームウィジェットは、他のウィジェットを整理するためのコンテナウィジェットとして使用されます。
6	Label ラベルウィジェットは、他のウィジェットに単一行のキャプションを提供するために使用されます。 画像を含めることもできます。
7	Listbox リストボックスウィジェットは、ユーザーにオプションのリストを提供するために使用されます。
8	Menubutton Menubuttonウィジェットは、アプリケーションでメニューを表示するために使用されます。
9	Menu メニューウィジェットは、ユーザーにさまざまなコマンドを提供するために使用されます。 これらのコマンドは、メニューボタン内に含まれています。
10	Message メッセージウィジェットは、ユーザーから値を受け取るための複数行のテキストフィールドを表示するために使用されます。
11	Radiobutton ラジオボタンウィジェットは、ラジオボタンとして多数のオプションを表示するために使用されます。 ユーザーは一度に1つのオプションのみを選択できます。
12	Scale スケールウィジェットは、スライダーウィジェットを提供するために使用されます。
13	Scrollbar Scrollbarウィジェットは、リストボックスなどのさまざまなウィジェットにスクロール機能を追加するために使用されます。
14	Text テキストウィジェットは、テキストを複数行で表示するために使用されます。
15	Toplevel トップレベルウィジェットは、個別のウィンドウコンテナを提供するために使用されます。
16	Spinbox Spinboxウィジェットは、標準のTkinterエントリウィジェットのバリアントであり、固定数の値から選択するために使用できます。
17	PanedWindow PanedWindowは、水平または垂直に配置された任意の数のペインを含むことができるコンテナウィジェットです。
18	LabelFrame ラベルフレームは、単純なコンテナウィジェットです。 その主な目的は、複雑なウィンドウレイアウトのスペーサーまたはコンテナとして機能することです。
19	tkMessageBox このモジュールは、アプリケーションでメッセージボックスを表示するために使用されます。

標準属性

サイズ、色、フォントなどの一般的な属性の指定方法を見てみましょう。

• リンク：/python3/tk_dimensions [寸法]
• リンク：/python3/tk_colors [色]
• リンク：/python3/tk_fonts [フォント]
• リンク：/python3/tk_anchors [アンカー]
• リンク：/python3/tk_relief [レリーフスタイル]
• リンク：/python3/tk_bitmaps [ビットマップ]
• リンク：/python3/tk_cursors [カーソル]

ジオメトリ管理

すべてのTkinterウィジェットは、特定のジオメトリ管理メソッドにアクセスできます。これには、親ウィジェットエリア全体にウィジェットを整理する目的があります。 Tkinterは、pack、grid、およびplaceのジオメトリマネージャークラスを公開します。

• link：/python3/tk_pack [The pack（）メソッド]-このジオメトリマネージャは、ウィジェットを親ウィジェットに配置する前に、ブロックに編成します。
• link：/python3/tk_grid [The grid（）メソッド]-このジオメトリマネージャーは、親ウィジェット内のテーブルのような構造でウィジェットを整理します。
• link：/python3/tk_place [place（）メソッド]-このジオメトリマネージャは、ウィジェットを親ウィジェット内の特定の位置に配置することでウィジェットを整理します。

Python 3-Cを使用した拡張プログラミング

C、C＆plus;＆plus;、Javaなどのコンパイル済み言語を使用して記述するコードは、別のPythonスクリプトに統合またはインポートできます。 このコードは「拡張機能」と見なされます。

Python拡張モジュールは、通常のCライブラリにすぎません。 Unixマシンでは、これらのライブラリは通常 .so （共有オブジェクト用）で終わります。 Windowsマシンでは、通常、*。dll *（動的にリンクされたライブラリ用）が表示されます。

拡張機能を記述するための前提条件

拡張機能の作成を開始するには、Pythonヘッダーファイルが必要になります。

• Unixマシンでは、通常、python2.5-devなどの開発者固有のパッケージをインストールする必要があります。
• Windowsユーザーは、バイナリPythonインストーラーを使用すると、パッケージの一部としてこれらのヘッダーを取得します。

さらに、CまたはC＆plus;＆plus;について十分な知識があることを前提としています。 Cプログラミングを使用してPython拡張機能を記述します。

Python拡張機能の最初の検討

Python拡張モジュールを初めて見るには、コードを4つの部分にグループ化する必要があります-

• ヘッダーファイル_Python.h_。
• モジュールからインターフェイスとして公開するC関数。
• Python開発者が関数を拡張モジュール内のC関数と見なすときに関数の名前をマッピングするテーブル。 *初期化関数。

ヘッダーファイルPython.h

Cソースファイルに_Python.h_ヘッダーファイルを含める必要があります。これにより、モジュールをインタープリターにフックするために使用される内部Python APIにアクセスできます。

必要な他のヘッダーの前にPython.hをインクルードしてください。 Pythonから呼び出したい関数のインクルードに従う必要があります。

C関数

あなたの関数のC実装の署名は、常に次の3つの形式のいずれかを取ります-

static PyObject* MyFunction( PyObject *self, PyObject *args );

static PyObject *MyFunctionWithKeywords(PyObject *self, PyObject *args, PyObject *kw);

static PyObject *MyFunctionWithNoArgs( PyObject *self );

上記の各宣言はPythonオブジェクトを返します。 Pythonには、Cにあるような_void_関数などはありません。 関数が値を返さないようにするには、Pythonの None 値に相当するCを返します。 Pythonヘッダーは、これを行うマクロPy_RETURN_NONEを定義します。

C関数の名前は、拡張モジュールの外では決して見られないため、好きな名前にできます。 それらは_static_関数として定義されています。

あなたのC関数は通常、ここに示すように、Pythonモジュールと関数名を組み合わせて名前が付けられます-

static PyObject *module_func(PyObject *self, PyObject *args) {
  /*Do your stuff here.*/
   Py_RETURN_NONE;
}

これは、モジュール_module_内の_func_と呼ばれるPython関数です。 C関数へのポインターを、通常ソースコードで次に来るモジュールのメソッドテーブルに配置します。

メソッドマッピングテーブル

このメソッドテーブルは、PyMethodDef構造の単純な配列です。 その構造は次のようになります-

struct PyMethodDef {
   char *ml_name;
   PyCFunction ml_meth;
   int ml_flags;
   char *ml_doc;
};

これは、この構造のメンバーの説明です-

• ml_name -Pythonプログラムで使用されるときにPythonインタープリターが提示する関数の名前です。
• ml_meth -これは、前のセクションで説明した署名のいずれかを持つ関数のアドレスです。
• ml_flags -これは、インタプリタにml_methの3つの署名のどれを使用しているかを伝えます。
• 通常、このフラグの値はMETH_VARARGSです。
• 関数にキーワード引数を許可する場合は、このフラグをMETH_KEYWORDSとビット単位で論理和することができます。
• また、引数を受け入れたくないことを示すMETH_NOARGSの値を持つこともできます。
• ml_doc -これは関数のdocstringであり、作成する気がない場合はNULLになる可能性があります。

このテーブルは、適切なメンバーのNULL値と0値で構成されるセンチネルで終了する必要があります。

例

上記で定義された関数の場合、次のメソッドマッピングテーブルがあります-

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

初期化関数

拡張モジュールの最後の部分は、初期化関数です。 この関数は、モジュールがロードされるときにPythonインタープリターによって呼び出されます。 関数の名前は initModule である必要があります。ここで、_Module_はモジュールの名前です。

初期化関数は、ビルドするライブラリからエクスポートする必要があります。 PythonヘッダーはPyMODINIT_FUNCを定義して、コンパイルする特定の環境で発生する適切な呪文を含めます。 しなければならないことは、関数を定義するときにそれを使用することだけです。

あなたのC初期化関数は一般的に次の全体的な構造を持っています-

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

ここに Py_InitModule3 関数の説明があります-

• func -これはエクスポートされる関数です。
• module_methods -これは上で定義されたマッピングテーブル名です。
• docstring -これはあなたの拡張機能で与えたいコメントです。

これをすべてまとめると、次のようになります-

#include <Python.h>

static PyObject *module_func(PyObject *self, PyObject *args) {
  /*Do your stuff here.*/
   Py_RETURN_NONE;
}

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}

例

上記のすべての概念を利用する簡単な例-

#include <Python.h>

static PyObject* helloworld(PyObject *self)
{
   return Py_BuildValue("s", "Hello, Python extensions!!");
}

static char helloworld_docs[] =
   "helloworld( ): Any message you want to put here!!\n";

static PyMethodDef helloworld_funcs[] = {
   {"helloworld", (PyCFunction)helloworld,
   METH_NOARGS, helloworld_docs},
   {NULL}
};

void inithelloworld(void)
{
   Py_InitModule3("helloworld", helloworld_funcs, "Extension module example!");
}

ここでは、_Py_BuildValue_関数を使用してPython値を作成します。 上記のコードをhello.cファイルに保存します。 このモジュールをコンパイルしてインストールし、Pythonスクリプトから呼び出す方法を確認します。

拡張機能の構築とインストール

distutils_パッケージを使用すると、純粋なPythonモジュールと拡張モジュールの両方のPythonモジュールを標準的な方法で簡単に配布できます。 モジュールはソース形式で配布され、通常_setup.py asと呼ばれるセットアップスクリプトを介してビルドおよびインストールされます。

上記のモジュールでは、次のsetup.pyスクリプトを準備する必要があります-

from distutils.core import setup, Extension
setup(name = 'helloworld', version = '1.0',  \
   ext_modules = [Extension('helloworld', ['hello.c'])])

今、次のコマンドを使用します。これは、必要なすべてのコンパイルとリンクのステップを、適切なコンパイラーとリンカーのコマンドとフラグで実行し、結果の動的ライブラリを適切なディレクトリにコピーします-

$ python setup.py install

Unixベースのシステムでは、ほとんどの場合、このコマンドをrootとして実行して、site-packagesディレクトリへの書き込み許可を得る必要があります。 通常、これはWindowsでは問題になりません。

拡張機能のインポート

拡張機能をインストールしたら、次のようにPythonスクリプトでその拡張機能をインポートして呼び出すことができます-

例

#!/usr/bin/python3
import helloworld

print helloworld.helloworld()

出力

これは、次の結果を生成します-

Hello, Python extensions!!

関数パラメーターを渡す

ほとんどの場合、引数を受け入れる関数を定義する必要があるため、C関数に他のシグネチャのいずれかを使用できます。 たとえば、いくつかのパラメータを受け入れる次の関数は、このように定義されます-

static PyObject* module_func(PyObject *self, PyObject *args) {
  /*Parse args and do something interesting here.*/
   Py_RETURN_NONE;
}

新しい関数のエントリを含むメソッドテーブルは次のようになります-

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { "func", module_func, METH_VARARGS, NULL },
   { NULL, NULL, 0, NULL }
};

API _PyArg_ParseTuple_関数を使用して、C関数に渡された1つのPyObjectポインターから引数を抽出できます。

PyArg_ParseTupleの最初の引数はargs引数です。 これは、_parsing_になるオブジェクトです。 2番目の引数は、表示されると予想される引数を記述するフォーマット文字列です。 各引数は、次のようにフォーマット文字列の1つ以上の文字で表されます。

static PyObject *module_func(PyObject *self, PyObject *args) {
   int i;
   double d;
   char *s;

   if (!PyArg_ParseTuple(args, "ids", &i, &d, &s)) {
      return NULL;
   }

  /*Do something interesting here.*/
   Py_RETURN_NONE;
}

出力

モジュールの新しいバージョンをコンパイルしてインポートすると、任意のタイプの任意の数の引数で新しい関数を呼び出すことができます-

module.func(1, s = "three", d = 2.0)
module.func(i = 1, d = 2.0, s = "three")
module.func(s = "three", d = 2.0, i = 1)

おそらく、さらに多くのバリエーションを考え出すことができます。

PyArg_ParseTuple関数

*PyArg_ParseTuple* 関数の標準シグネチャは次のとおりです-

int PyArg_ParseTuple(PyObject* tuple,char *format,...)

この関数は、エラーの場合は0を返し、成功の場合は0以外の値を返します。 Tupleは、C関数の2番目の引数であるPyObject* です。 ここで、_format_は、必須およびオプションの引数を説明するC文字列です。

*PyArg_ParseTuple* 関数のフォーマットコードのリストは次のとおりです-

Code	C type	Meaning
c	char	A Python string of length 1 becomes a C char.
d	double	A Python float becomes a C double.
f	float	A Python float becomes a C float.
i	int	A Python int becomes a C int.
l	long	A Python int becomes a C long.
L	long long	A Python int becomes a C long long
O	PyObject*	Gets non-NULL borrowed reference to Python argument.
s	char*	Python string without embedded nulls to C char*.
s#	char*PLUSint	Any Python string to C address and length.
t#	char*PLUSint	Read-only single-segment buffer to C address and length.
u	Py_UNICODE*	Python Unicode without embedded nulls to C.
u#	Py_UNICODE*PLUSint	Any Python Unicode C address and length.
w#	char*+int	Read/write single-segment buffer to C address and length.
z	char*	Like s, also accepts None (sets C char* to NULL).
z#	char*+int	Like s#, also accepts None (sets C char *to NULL).
(…​)	as per …​	A Python sequence is treated as one argument per item.
The following arguments are optional.	:
Format end, followed by function name for error messages.	;

戻り値

_Py_BuildValue_は、_PyArg_ParseTuple_と同様にフォーマット文字列を受け取ります。 構築する値のアドレスを渡す代わりに、実際の値を渡します。 追加機能を実装する方法を示す例があります-

static PyObject* foo_add(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("i", a + b);
}

これは、Pythonで実装した場合の外観です-

def add(a, b):
   return (a + b)

次のように、関数から2つの値を返すことができます。 これは、Pythonのリストを使用してキャプチャされます。

static PyObject *foo_add_subtract(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("ii", a + b, a - b);
}

これは、Pythonで実装した場合の外観です-

def add_subtract(a, b):
   return (a + b, a - b)

_Py_BuildValue_関数

*Py_BuildValue* 関数の標準シグネチャは次のとおりです-

PyObject* Py_BuildValue(char *format,...)

ここで、_format_は、ビルドするPythonオブジェクトを記述するC文字列です。 _Py_BuildValue_の以下の引数は、結果が構築されるC値です。 _PyObject* _の結果は新しい参照です。

次の表は、一般に使用されるコード文字列のリストです。コード文字列のうち、0個以上が文字列形式に結合されています。

Code	C type	Meaning
c	char	A C char becomes a Python string of length 1.
d	double	A C double becomes a Python float.
f	float	A C float becomes a Python float.
i	int	A C int becomes a Python int.
l	long	A C long becomes a Python int.
N	PyObject*	Passes a Python object and steals a reference.
O	PyObject*	Passes a Python object and INCREFs it as normal.
O&	convertPLUSvoid*	Arbitrary conversion
s	char*	C 0-terminated char* to Python string, or NULL to None.
s#	char*PLUSint	C char* and length to Python string, or NULL to None.
u	Py_UNICODE*	C-wide, null-terminated string to Python Unicode, or NULL to None.
u#	Py_UNICODE*PLUSint	C-wide string and length to Python Unicode, or NULL to None.
w#	char*PLUSint	Read/write single-segment buffer to C address and length.
z	char*	Like s, also accepts None (sets C char* to NULL).
z#	char*PLUSint	Like s#, also accepts None (sets C char* to NULL).
(…​)	as per …​	Builds Python tuple from C values.
[…​]	as per …​	Builds Python list from C values.
\{…​}	as per …​	Builds Python dictionary from C values, alternating keys and values.

コード\ {…​}は、キーと値を交互に使用して、偶数個のC値から辞書を作成します。 たとえば、Py_BuildValue（ "\ {issi}"、23、 "zig"、 "zag"、42）は、Pythonの\ {23： 'zig'、 'zag'：42}のような辞書を返します。 Python3-python-questions-answers

Python 3-ツール/ユーティリティ

標準ライブラリには、モジュールとしてもコマンドラインユーティリティとしても使用できる多数のモジュールが付属しています。

_dis_モジュール：

disモジュールはPython逆アセンブラーです。 バイトコードを、人間が消費するのにやや適した形式に変換します。

コマンドラインから逆アセンブラを実行できます。 指定されたスクリプトをコンパイルし、逆アセンブルされたバイトコードをSTDOUTに出力します。 disをモジュールとして使用することもできます。 dis 関数は、クラス、メソッド、関数、またはコードオブジェクトを単一の引数として受け取ります。

例

#!/usr/bin/python3
import dis

def sum():
   vara = 10
   varb = 20

   sum = vara + varb
   print ("vara + varb = %d" % sum)

# Call dis function for the function.

dis.dis(sum)

これは、次の結果を生成します-

  6           0 LOAD_CONST               1 (10)
              3 STORE_FAST               0 (vara)

  7           6 LOAD_CONST               2 (20)
              9 STORE_FAST               1 (varb)

  9          12 LOAD_FAST                0 (vara)
             15 LOAD_FAST                1 (varb)
             18 BINARY_ADD
             19 STORE_FAST               2 (sum)

 10          22 LOAD_CONST               3 ('vara + varb = %d')
             25 LOAD_FAST                2 (sum)
             28 BINARY_MODULO
             29 PRINT_ITEM
             30 PRINT_NEWLINE
             31 LOAD_CONST               0 (None)
             34 RETURN_VALUE

_pdb_モジュール

pdbモジュールは、標準のPythonデバッガーです。 これは、bdbデバッガーフレームワークに基づいています。

あなたは、コマンドラインからデバッガを実行することができます（次の行に移動し、使用可能なコマンドのリストを取得するのに役立つn [またはnext]を入力します）-

例：

*pdb.py* を実行する前に、パスをPython libディレクトリに適切に設定します。 上記の例で試してみましょうsum.py-

$pdb.py sum.py
>/test/sum.py(3)<module>()
-> import dis
(Pdb) n
>/test/sum.py(5)<module>()
-> def sum():
(Pdb) n
>/test/sum.py(14)<module>()
-> dis.dis(sum)
(Pdb) n
  6           0 LOAD_CONST               1 (10)
              3 STORE_FAST               0 (vara)

  7           6 LOAD_CONST               2 (20)
              9 STORE_FAST               1 (varb)

  9          12 LOAD_FAST                0 (vara)
             15 LOAD_FAST                1 (varb)
             18 BINARY_ADD
             19 STORE_FAST               2 (sum)

 10          22 LOAD_CONST               3 ('vara + varb = %d')
             25 LOAD_FAST                2 (sum)
             28 BINARY_MODULO
             29 PRINT_ITEM
             30 PRINT_NEWLINE
             31 LOAD_CONST               0 (None)
             34 RETURN_VALUE
--Return--
>/test/sum.py(14)<module>()->None
-v dis.dis(sum)
(Pdb) n
--Return--
> <string>(1)<module>()->None
(Pdb)

_profile_モジュール

プロファイルモジュールは、標準のPythonプロファイラーです。 あなたは、コマンドラインからプロファイラを実行することができます-

例

次のプログラムのプロファイルを作成してみましょう-

#!/usr/bin/python3

vara = 10
varb = 20

sum = vara + varb
print "vara + varb = %d" % sum

さて、次のようにこのファイル_sum.py_上で cProfile.py を実行してみてください-

$cProfile.py sum.py
vara + varb = 30
         4 function calls in 0.000 CPU seconds

   Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno
   1    0.000    0.000    0.000    0.000 <string>:1(<module>)
   1    0.000    0.000    0.000    0.000 sum.py:3(<module>)
   1    0.000    0.000    0.000    0.000 {execfile}
   1    0.000    0.000    0.000    0.000 {method ......}

_tabnanny_モジュール

tabnannyモジュールは、あいまいなインデントがないかPythonソースファイルをチェックします。 ファイルがインデントをオフにする方法でタブとスペースを混ぜている場合、あなたが使用しているタブサイズに関係なく、乳母は文句を言います-

例

次のプログラムのプロファイルを作成してみましょう-

#!/usr/bin/python3

vara = 10
varb = 20

sum = vara + varb
print "vara + varb = %d" % sum

tabnanny.pyで正しいファイルを試してみると、次のように文句を言うことはありません-

$tabnanny.py -v sum.py
'sum.py': Clean bill of health.