Python-quick-guide

Python-概要

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機能

Pythonの機能が含まれます-

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

上記の機能とは別に、Pythonには優れた機能の大きなリストがありますが、以下にリストされているものはほとんどありません-

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

Python-環境設定

Pythonは、LinuxやMac OS Xを含むさまざまなプラットフォームで利用できます。 Python環境のセットアップ方法を理解しましょう。

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

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

• Unix（Solaris、Linux、FreeBSD、AIX、HP/UX、SunOS、IRIXなど）
• 9x/NT/2000に勝つ
• Macintosh（Intel、PPC、68K）
• OS/2
• DOS（複数のバージョン）
• PalmOS
• ノキアの携帯電話
• Windows CE
• Acorn/RISC OS
• BeOS
• アミガ
• VMS/OpenVMS
• QNX
• VxWorks
• サイオン
• PythonはJavaおよび.NET仮想マシンにも移植されています

Pythonを入手する

最新のソースコード、バイナリ、ドキュメント、ニュースなどは、Python [[1]]

Pythonドキュメントはhttps://www.python.org/doc/からダウンロードできます。 ドキュメントは、HTML、PDF、およびPostScript形式で入手できます。

Pythonをインストールする

Pythonディストリビューションは、さまざまなプラットフォームで利用できます。 プラットフォームに適用可能なバイナリコードのみをダウンロードし、Pythonをインストールする必要があります。

プラットフォームのバイナリコードが利用できない場合は、ソースコードを手動でコンパイルするCコンパイラが必要です。 ソースコードをコンパイルすると、インストールに必要な機能の選択に関して柔軟性が高まります。

Pythonをさまざまなプラットフォームにインストールする簡単な概要を次に示します-

UnixおよびLinuxのインストール

Unix/LinuxマシンにPythonをインストールする簡単な手順を以下に示します。

• Webブラウザーを開き、https://www.python.org/downloads/にアクセスします。
• リンクに従って、Unix/Linuxで利用可能なzip形式のソースコードをダウンロードします。
• ファイルをダウンロードして抽出します。
• 一部のオプションをカスタマイズする場合は、_Modules/Setup_ファイルを編集します。
• ./configureスクリプトを実行します
• make
• インストールする

これにより、Pythonは標準の場所_/usr/local/bin_にインストールされ、そのライブラリは_/usr/local/lib/pythonXX_にインストールされます（XXはPythonのバージョンです）。

Windowsインストール

PythonをWindowsマシンにインストールする手順は次のとおりです。

• Webブラウザーを開き、https://www.python.org/downloads/にアクセスします。
• Windowsインストーラーの_python-XYZ.msi_ファイルのリンクをたどります。ここで、XYZはインストールする必要のあるバージョンです。
• このインストーラー_python-XYZ.msi_を使用するには、WindowsシステムがMicrosoft Installer 2.0をサポートしている必要があります。 インストーラファイルをローカルマシンに保存し、実行して、マシンがMSIをサポートしているかどうかを確認します。
• ダウンロードしたファイルを実行します。 これにより、非常に使いやすいPythonインストールウィザードが表示されます。 デフォルト設定をそのまま使用し、インストールが完了するまで待ちます。完了です。

Macintoshインストール

最近のMacにはPythonがインストールされていますが、数年前のものである可能性があります。 Macでの開発をサポートする追加のツールとともに現在のバージョンを取得する手順については、https://www.python.org/download/mac/[http://www.python.org/download/mac/]を参照してください。 Mac OS X 10.3（2003年にリリース）より前の古いMac OSの場合、MacPythonが利用可能です。

Jack Jansenがそれを管理しており、彼のWebサイト（http://www.cwi.nl/~jack/macpythonl）でドキュメント全体に完全にアクセスできます。 Mac OSインストールの完全なインストール詳細を見つけることができます。

PATHのセットアップ

プログラムやその他の実行可能ファイルは多くのディレクトリにある可能性があるため、オペレーティングシステムは、OSが実行可能ファイルを検索するディレクトリをリストする検索パスを提供します。

パスは環境変数に保存されます。環境変数は、オペレーティングシステムによって管理される名前付き文字列です。 この変数には、コマンドシェルおよび他のプログラムで利用可能な情報が含まれています。

*path* 変数の名前は、UnixではPATH、WindowsではPathです（Unixでは大文字と小文字が区別されますが、Windowsでは区別されません）。

Mac OSでは、インストーラーがパスの詳細を処理します。 特定のディレクトリからPythonインタープリターを起動するには、Pythonディレクトリをパスに追加する必要があります。

Unix/Linuxでのパスの設定

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

• * cshシェル*-setenv PATH "$ PATH：/usr/local/bin/python"と入力してEnterを押します。
• * bashシェル（Linux）*で-export PATH = "$ PATH：/usr/local/bin/python"と入力し、Enterを押します。
• * shシェルまたはkshシェル*-PATH = "$ PATH：/usr/local/bin/python"と入力し、Enterを押します。
• 注意-/usr/local/bin/pythonは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 詳細出力（インポートステートメントの詳細なトレース）。
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環境が適切に設定され、完全に正常に動作することを確認してください。

注-以降の章で説明するすべての例は、LinuxのCentOSフレーバーで利用可能なPython 2.4.3バージョンで実行されます。

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

Python-基本構文

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

最初のPythonプログラム

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

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

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

$ python
Python 2.4.3 (#1, Nov 11 2010, 13:34:43)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

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

>>> print "Hello, Python!"

Pythonの新しいバージョンを実行している場合、 print（ "Hello、Python！"）; のように、括弧付きのprintステートメントを使用する必要があります。 ただし、Pythonバージョン2.4.3では、これにより次の結果が生成されます-

Hello, Python!

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

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

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

print "Hello, Python!"

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

$ python test.py

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

Hello, Python!

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

#!/usr/bin/python

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

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

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

予約語

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

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

行とインデント

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

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

if True:
   print "True"
else:
   print "False"

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

if True:
print "Answer"
print "True"
else:
print "Answer"
print "False"

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

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

#!/usr/bin/python

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 = raw_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/python

# 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/python

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

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

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

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

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：/python/python_command_line_arguments [コマンドライン引数]は高度なトピックであり、Pythonの残りの概念を終えた後、少し検討する必要があります。

Python-変数タイプ

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

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

変数への値の割り当て

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

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

#!/usr/bin/python

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は4つの異なる数値型をサポートしています-

• int（符号付き整数）
• long（long integer、8進数と16進数で表すこともできます）
• float（浮動小数点の実数値）
• 複素数（複素数）

例

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

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3+e18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

• Pythonでは、小文字のlをlongで使用できますが、数字の1との混乱を避けるために、大文字のLのみを使用することをお勧めします。 Pythonは、大文字のLで長整数を表示します。
• 複素数は、x + yjで示される順序付けられた実浮動小数点数のペアで構成されます。ここで、xとyは実数、jは虚数単位です。

Python文字列

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

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

#!/usr/bin/python

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の終わりまでインデックスを使用して、スライス演算子（[]および[：]）を使用してアクセスできます。 プラス（+）記号はリスト連結演算子であり、アスタリスク（*）は繰り返し演算子です。 たとえば-

#!/usr/bin/python

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.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

Pythonタプル

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

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

#!/usr/bin/python

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

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

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

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

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

#!/usr/bin/python

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/python

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
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

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

データ型変換

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

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

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

Python-基本演算子

演算子は、オペランドの値を操作できる構造です。

式4 + 5 = 9を考えてください。 ここで、4と5はオペランドと呼ばれ、+は演算子と呼ばれます。

オペレーターの種類

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

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

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

Pythonの算術演算子

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

{空} [link：/python/arithmetic_operators_example [例を表示]]

Operator	Description	Example
+ Addition	Adds values on either side of the operator.	a + b = 30
- Subtraction	Subtracts right hand operand from left hand operand.	a – b = -10
*Multiplication	Multiplies values on either side of the operator	a* b = 200
/Division	Divides left hand operand by right hand operand	b/a = 2
% Modulus	Divides left hand operand by right hand operand and returns remainder	b % a = 0
** 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：/python/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 values of two operands are not equal, then condition becomes true.	(a <> b) is true. This is similar to != operator.
>	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：/python/assignment_operators_example [例を表示]]

Operator	Description	Example
=	Assigns values from right side operands to left side operand	c = a + b assigns value of a + b into c
+= Add AND	It adds right operand to the left operand and assign the result to left operand	c += a is equivalent to c = c + 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/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;バイナリ形式では、それらの値はそれぞれ0011 1100と0000 1101になります。 次の表に、Python言語でサポートされているビットごとの演算子とそれらの例をそれぞれ示します。上記の2つの変数（aおよびb）をオペランドとして使用します-

a = 0011 1100

b = 0000 1101

a＆b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

〜a = 1100 0011

Python言語でサポートされている次のビット単位の演算子があります

{空} [link：/python/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 operands 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 operands value is moved right by the number of bits specified by the right operand. |a >> 2 = 15 (means 0000 1111)
|===

=== Python論理演算子

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

{空} [link：/python/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 true. |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 false.
|===

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

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

{空} [link：/python/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：/python/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：/python/operators_precedence_example [例を表示]]

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

べき乗（累乗）

|2 a| *~ + -*

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

|3 a|
 */％//*

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

|4 a| *+ -*

加減

|5 a| *>> <<*

左右のビット単位シフト

|6 a| *&*

ビット単位の「AND」

|7 a| *^ |*

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

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

比較演算子

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

平等演算子

|10 a| *= %=/=//= -= += *= **=*

割り当て演算子

|11 a| *is is not*

アイデンティティ演算子

|12 a| *in not in*

会員事業者

|13 a| *not or and*

論理演算子

|===

Python-意思決定

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

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

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

Pythonでの意思決定ステートメント

Pythonプログラミング言語は、 non-zero および non-null 値をTRUEと想定し、 zero または 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/python

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

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

Value of expression is 100
Good bye!

Python-ループ

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

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

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

ループアーキテクチャ

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

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

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

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

Pythonは、次の制御ステートメントをサポートしています。 詳細を確認するには、次のリンクをクリックしてください。

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

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

Python-数字

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

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

var1 = 1
var2 = 10

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

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

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

del var
del var_a, var_b

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

• * int（符号付き整数）*-整数または整数と呼ばれることが多く、小数点のない正または負の整数です。
• * long（long integers）*-longsとも呼ばれ、無制限のサイズの整数で、整数のように書かれ、その後に大文字または小文字のLが続きます。
• * 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プログラミングでは複素数はあまり使用されません。

例

数字の例をいくつか示します

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEL	32.3+e18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

• Pythonでは、小文字のLをlongで使用できますが、数字の1との混乱を避けるために、大文字のLのみを使用することをお勧めします。 Pythonは、大文字のLで長整数を表示します。
• 複素数は、a + 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
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-文字列

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

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

文字列の値へのアクセス

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

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

#!/usr/bin/python

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/python

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
+	Concatenation - Adds values on either side of the operator	a + 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/python

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

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

My name is Zara and weight is 21 kg!

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

Format Symbol	Conversion
%c	character
%s	string conversion via str() prior to formatting
%i	signed decimal integer
%d	signed decimal integer
%u	unsigned decimal integer
%o	octal integer
%x	hexadecimal integer (lowercase letters)
%X	hexadecimal integer (UPPERcase letters)
%e	exponential notation (with lowercase 'e')
%E	exponential notation (with UPPERcase 'E')
%f	floating point real number
%g	the shorter of %f and %e
%G	the shorter of %f and %E

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

Symbol	Functionality
*	argument specifies width or precision
-	left justification
+	display the sign
<sp>	leave a blank space before a positive number
#	add the octal leading zero ( '0' ) or hexadecimal leading '0x' or '0X', depending on whether 'x' or 'X' were used.
0	pad from left with zeros (instead of spaces)
%	'%%' leaves you with a single literal '%'
(var)	mapping variable (dictionary arguments)
m.n.	m is the minimum total width and n is the number of digits to display after the decimal point (if appl.)

トリプルクォート

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

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

#!/usr/bin/python

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/python

print 'C:\\nowhere'

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

C:\nowhere

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

#!/usr/bin/python

print r'C:\\nowhere'

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

C:\\nowhere

Unicode文字列

Pythonの通常の文字列は8ビットASCIIとして内部的に保存されますが、Unicode文字列は16ビットUnicodeとして保存されます。 これにより、世界のほとんどの言語の特殊文字を含む、より多様な文字セットが可能になります。 私はUnicode文字列の扱いを次のように制限します-

#!/usr/bin/python

print u'Hello, world!'

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

Hello, world!

ご覧のとおり、Unicode文字列では接頭辞uが使用されますが、生の文字列では接頭辞rが使用されます。

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

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

Sr.No.	Methods with Description
1	capitalize() 文字列の最初の文字を大文字にします
2	center(width, fillchar) 幅の合計列の中央に元の文字列をスペースで埋めた文字列を返します。
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-リスト

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/python

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/python

list = ['physics', 'chemistry', 1997, 2000];
print "Value available at index 2 : "
print list[2]
list[2] = 2001;
print "New value available at index 2 : "
print list[2]

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

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

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

リスト要素を削除

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

#!/usr/bin/python

list1 = ['physics', 'chemistry', 1997, 2000];
print list1
del list1[2];
print "After deleting value at index 2 : "
print list1

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

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

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

基本的なリスト操作

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

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

Python Expression	Results	Description
len([1, 2, 3])	3	Length
[1, 2, 3] + [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,	1 2 3	Iteration

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

リストはシーケンスであるため、リストのインデックス作成とスライスは、文字列の場合と同じように機能します。

次の入力を想定-

L = ['spam', 'Spam', 'SPAM!']

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

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

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

Sr.No.	Function with Description
1	cmp(list1, list2) 両方のリストの要素を比較します。
2	len(list) リストの全長を示します。
3	max(list) 最大値でリストからアイテムを返します。
4	min(list) 最小値を持つリストからアイテムを返します。
5	list(seq) タプルをリストに変換します。

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

Sr.No.	Methods with 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-タプル

タプルは、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/python

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/python

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/python

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

基本的なタプル操作

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

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

Python Expression	Results	Description
len1, 2, 31, 2, 3	3	Length
(1, 2, 3) + (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,	1 2 3	Iteration

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

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

L = ('spam', 'Spam', 'SPAM!')

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

囲みデリミタなし

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

#!/usr/bin/python

print 'abc', -4.24e93, 18+6.6j, 'xyz';
x, y = 1, 2;
print "Value of x , y : ", x,y;

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

abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

組み込みタプル関数

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

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

Python-辞書

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

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

辞書の値へのアクセス

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

#!/usr/bin/python

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/python

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

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

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

辞書の更新

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

#!/usr/bin/python

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/python

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']

これにより、次の結果が生成されます。 *デル辞書*辞書がもはや存在しないため、例外が発生することに注意してください-

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/python

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

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

dict['Name']:  Manni

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

#!/usr/bin/python

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: unhashable type: 'list'

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

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

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

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

Sr.No.	Methods with 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) 辞書のキーが_dict_の場合は_true_、それ以外の場合は_false_を返します
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-日付と時刻

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

ティックとは何ですか？

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

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

例

#!/usr/bin/python
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: 7186862.73399

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

TimeTupleとは何ですか？

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

Index	Field	Values
0	4-digit year	2008
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

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

Index	Attributes	Values
0	tm_year	2008
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

現在の時刻を取得する

epoch_浮動小数点値からの_secondsからタイムタプルへの時刻を変換するには、浮動小数点値を、9つの項目すべてが有効なタイムタプルを返す関数（localtimeなど）に渡します。

#!/usr/bin/python
import time;

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

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

Local current time : time.struct_time(tm_year=2013, tm_mon=7,
tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

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

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

#!/usr/bin/python
import time;

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

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

Local current time : Tue Jan 13 10:17:09 2009

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

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

#!/usr/bin/python
import calendar

cal = calendar.month(2008, 1)
print "Here is the calendar:"
print cal

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

Here is the calendar:
   January 2008
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 30 31

_time_モジュール

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

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

_calendar_モジュール

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

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

ここに_calendar_モジュールで利用可能な機能のリストがあります-

Sr.No.	Function with Description
1	calendar.calendar(year,w=2,l=1,c=6) cスペースで区切られた3つの列にフォーマットされた年yearのカレンダーを含む複数行の文字列を返します。 wは各日付の文字の幅です。各行の長さは21 w + 18 + 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 + 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-関数

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

既にご存じのとおり、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/python

# 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("I'm first call to user defined function!")
printme("Again second call to the same function")

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

I'm first call to user defined function!
Again second call to the same function

参照渡しと値渡し

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

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   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

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

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

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

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4]; # This would assig 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/python

# 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/python

# 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/python

# 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/python

# 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/python

# 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

_Anonymous_関数

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

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

構文

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

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

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

#!/usr/bin/python

# 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/python

# 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/python

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-モジュール

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

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

例

_aname_というモジュールのPythonコードは、通常_aname.py_という名前のファイルにあります。 以下に、単純なモジュールsupport.pyの例を示します

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

_import_ステートメント

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

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

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

#!/usr/bin/python

# 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をインポートするには、次のステートメントを使用します-

from fib import fibonacci

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

_from …​ import *_ステートメント

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

from modname import*

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

モジュールの特定

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

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

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

_PYTHONPATH_変数

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

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

set PYTHONPATH = c:\python20\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/python

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/python

# 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/python

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/python

# 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

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

Python-ファイルI/O

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

画面への印刷

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

#!/usr/bin/python

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

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

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

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

Pythonは、標準入力からテキストの行を読み取るための2つの組み込み関数を提供します。デフォルトでは、キーボードから入力されます。 これらの機能は-

• raw_input
• 入力

_raw_input_関数

_raw_input（[prompt]）_関数は、標準入力から1行を読み取り、それを文字列として返します（末尾の改行を削除します）。

#!/usr/bin/python

str = raw_input("Enter your input: ")
print "Received input is : ", str

これにより、文字列を入力するように求められ、画面に同じ文字列が表示されます。 「Hello Python！」と入力すると、その出力は次のようになります-

Enter your input: Hello Python
Received input is :  Hello Python

_input_関数

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

#!/usr/bin/python

str = input("Enter your input: ")
print "Received input is : ", str

これは、入力された入力に対して次の結果を生成します-

Enter your input: [x*5 for x in range(2,10,2)]
Recieved input is :  [10, 20, 30, 40]

ファイルの開閉

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

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

_open_関数

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

_file_オブジェクトの属性

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

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

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

例

#!/usr/bin/python

# 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
print "Softspace flag : ", fo.softspace

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

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

_close（）_メソッド

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

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

構文

fileObject.close()

例

#!/usr/bin/python

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

# Close opend file
fo.close()

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

Name of the file:  foo.txt

ファイルの読み書き

_file_オブジェクトは、生活を楽にするアクセス方法のセットを提供します。 _read（）_メソッドと_write（）_メソッドを使用してファイルを読み書きする方法がわかります。

_write（）_メソッド

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

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

構文

fileObject.write(string)

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

例

#!/usr/bin/python

# Open a file
fo = open("foo.txt", "wb")
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/python

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

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

Read String is :  Python is

ファイルの位置

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

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

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

例

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

#!/usr/bin/python

# 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 opend 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/python
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/python
import os

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

Pythonのディレクトリ

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

_mkdir（）_メソッド

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

構文

os.mkdir("newdir")

例

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

#!/usr/bin/python
import os

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

_chdir（）_メソッド

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

構文

os.chdir("newdir")

例

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

#!/usr/bin/python
import os

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

_getcwd（）_メソッド

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

構文

os.getcwd()

例

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

#!/usr/bin/python
import os

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

_rmdir（）_メソッド

_rmdir（）_メソッドはディレクトリを削除します。ディレクトリはメソッドの引数として渡されます。

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

構文

os.rmdir('dirname')

例

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

#!/usr/bin/python
import os

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

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

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

• link：/python/file_methods [File Object Methods]：_file_オブジェクトは、ファイルを操作する関数を提供します。
• link：/python/os_file_methods [OSオブジェクトメソッド]：ファイルとディレクトリを処理するメソッドを提供します。

Python-例外処理

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

• 例外処理-これについては、このチュートリアルで説明します。 Pythonで使用できる標準の例外のリストを次に示します：link：/python/standard_exceptions [標準の例外]。
• Assertions -これはlink：/python/assertions_in_python [Assertions in 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	ZeroDivisionError すべての数値型でゼロによる除算またはモジュロが行われるときに発生します。
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	IOError オペレーティングシステム関連のエラーに対して発生します。
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ステートメントを使用して他の例外と同様にキャッチおよび処理できますが、処理されない場合、プログラムを終了し、トレースバックを生成します。

例

温度をケルビン度から華氏度に変換する関数を次に示します。 ゼロ度ケルビンはそれが取得するのと同じくらい寒いので、負の温度を見ると関数は消滅します-

#!/usr/bin/python
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/python

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/python

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_句

また、次のように定義された例外なしで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.
   ......................

finally句と一緒に_else_句を使用することはできません。

例

#!/usr/bin/python

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"

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

Error: can't find file or read data

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

#!/usr/bin/python

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"

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

例外の引数

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

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

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

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

例

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

#!/usr/bin/python

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError, 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 "Invalid level!", level
      # The code below to this would not be executed
      # if we raise the exception

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

try:
   Business Logic here...
except "Invalid level!":
   Exception handling here...
else:
   Rest of the code here...

ユーザー定義の例外

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-オブジェクト指向

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_は、このクラスのすべてのインスタンス間で値が共有されるクラス変数です。 これは、クラス内またはクラス外から_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/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

"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.age = 7  # Add an 'age' attribute.
emp1.age = 8  # Modify 'age' attribute.
del emp1.age  # Delete 'age' attribute.

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

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

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

組み込みクラスの属性

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

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

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

#!/usr/bin/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

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__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
<function displayCount at 0xb7c84994>, 'empCount': 2,
'displayEmployee': <function displayEmployee at 0xb7c8441c>,
'__doc__': 'Common base class for all employees',
'__init__': <function __init__ at 0xb7c846bc>}

オブジェクトの破棄（ガベージコレクション）

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/python

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

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

3083401324 3083401324 3083401324
Point destroyed

注-理想的には、クラスを別のファイルで定義し、_import_ステートメントを使用してメインプログラムファイルにインポートする必要があります。

クラスの継承

最初から始める代わりに、新しいクラス名の後に括弧で親クラスをリストすることにより、既存のクラスから派生させることにより、クラスを作成できます。

子クラスは親クラスの属性を継承し、それらの属性を子クラスで定義されているかのように使用できます。 子クラスは、親からのデータメンバーとメソッドをオーバーライドすることもできます。

構文

派生クラスは、親クラスのように宣言されます。ただし、継承する基本クラスのリストは、クラス名の後に指定されます-

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

例

#!/usr/bin/python

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 class B
.....

class C(A, B):   # subclass of A and B
.....

issubclass（）またはisinstance（）関数を使用して、2つのクラスとインスタンスの関係を確認できます。

• * issubclass（s​​ub、sup）ブール関数は、指定されたサブクラス *sub が実際にスーパークラス sup のサブクラスである場合にtrueを返します。
• * isinstance（obj、Class）*ブール関数は、_obj_がクラス_Class_のインスタンスであるか、クラスのサブクラスのインスタンスである場合にtrueを返します。

メソッドのオーバーライド

親クラスのメソッドはいつでもオーバーライドできます。 親のメソッドをオーバーライドする理由の1つは、サブクラスで特別な機能または異なる機能が必要になる場合があるためです。

例

#!/usr/bin/python

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/python

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/python

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-正規表現

_正規表現_は、パターンに保持されている特殊な構文を使用して、他の文字列または文字列のセットを一致または検索するのに役立つ特殊な文字シーケンスです。 正規表現は、UNIXの世界で広く使用されています。

Pythonモジュール re は、PythonでのPerlのような正規表現を完全にサポートします。 reモジュールは、正規表現のコンパイル中または使用中にエラーが発生した場合、例外re.errorを発生させます。

正規表現の処理に使用される2つの重要な関数について説明します。 しかし、最初に小さなこと：さまざまな文字があり、正規表現で使用されると特別な意味を持ちます。 正規表現を扱う際の混乱を避けるために、Raw文字列を* r’expression '*として使用します。

_match_関数

この関数は、オプションの_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/python
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

_search_関数

この関数は、オプションの_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 Methods & Description
1	group(num=0) このメソッドは、完全一致（または特定のサブグループnum）を返します
2	groups() このメソッドは、一致するすべてのサブグループをタプルで返します（ない場合は空になります）

例

#!/usr/bin/python
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!!"

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

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

マッチングと検索

Pythonは、正規表現に基づいた2つの異なるプリミティブ操作を提供します。

例

#!/usr/bin/python
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 --> searchObj.group() :  dogs

検索と置換

正規表現を使用する最も重要な re メソッドの1つは sub です。

構文

re.sub(pattern, repl, string, max=0)

このメソッドは、_string_内のRE _pattern_のすべての出現を_repl_に置き換え、_max_が指定されていない限り、すべての出現を置き換えます。 このメソッドは変更された文字列を返します。

例

#!/usr/bin/python
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 $を（文字列の末尾だけでなく）行の終わりに一致させ、^を（文字列の先頭だけでなく）任意の行の先頭に一致させます。
4	re.S 改行を含む任意の文字にピリオド（ドット）を一致させます。
5	re.U Unicode文字セットに従って文字を解釈します。 このフラグは、\ w、\ W、\ b、\ Bの動作に影響します。
6	re.X 「キューター」正規表現構文を許可します。 空白を無視し（セット[]内またはバックスラッシュでエスケープされた場合を除く）、エスケープされていない＃をコメントマーカーとして扱います。

正規表現パターン

制御文字を除き、（+？ 。 * ^ $（）[] \ {} | \）、すべての文字が一致します。 制御文字の前にバックスラッシュを付けることにより、制御文字をエスケープできます。

次の表は、Pythonで使用できる正規表現の構文を示しています-

Sr.No.	Pattern & Description
1	^ 行頭に一致します。
2	$ 行末に一致します。
3	. 改行を除く任意の1文字に一致します。 mオプションを使用すると、改行も一致させることができます。
4	[…​] 大括弧内の任意の1文字に一致します。
5	[^…​] 括弧内にない任意の1文字と一致します
6	re* 前の表現の0回以上の出現に一致します。
7	re+ 先行表現の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	ruby+ 「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\d+ グループなし：+ \ dを繰り返す
2	(\D\d)+ グループ化：+ \ D \ dペアを繰り返します
3	([Pp]ython(, )?)+ 「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(!+

アンカー

これには、一致位置を指定する必要があります。

Sr.No.	Example & Description
1	^Python 文字列または内部行の先頭で「Python」に一致
2	Python$ 文字列または行の末尾で「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-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 World - First CGI Program</title>'
print '</head>'
print '<body>'
print '<h2>Hello World! This is my first CGI program</h2>'
print '</body>'
print '</html>'

hello.pyをクリックすると、次の出力が生成されます-

"こんにちは世界" これは私の最初のCGIプログラムです

この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>"

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

こんにちは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はセキュアサーバーでのみ取得できます。 このフィールドが空白の場合、そのような制限はありません。
• Name = Value -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-MySQLデータベースアクセス

データベースインターフェイスのPython標準は、Python DB-APIです。 ほとんどのPythonデータベースインターフェイスは、この標準に準拠しています。

アプリケーションに適したデータベースを選択できます。 Python Database APIは、次のような幅広いデータベースサーバーをサポートしています-

• ガドフライ
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• オラクル
• Sybase

利用可能なPythonデータベースインターフェイスのリストは次のとおりです。http：//wiki.python.org/moin/DatabaseInterfaces [PythonデータベースインターフェイスとAPI]。 アクセスする必要のあるデータベースごとに個別のDB APIモジュールをダウンロードする必要があります。 たとえば、MySQLデータベースだけでなくOracleデータベースにもアクセスする必要がある場合、OracleとMySQLデータベースモジュールの両方をダウンロードする必要があります。

DB APIは、可能な限りPythonの構造と構文を使用してデータベースを操作するための最小限の標準を提供します。 このAPIには以下が含まれます-

• APIモジュールのインポート。
• データベースとの接続を取得します。
• SQLステートメントとストアドプロシージャの発行。
• 接続を閉じる

MySQLを使用してすべての概念を学習するので、MySQLdbモジュールについて話しましょう。

MySQLdbとは何ですか？

MySQLdbは、PythonからMySQLデータベースサーバーに接続するためのインターフェイスです。 Python Database API v2.0を実装し、MySQL C APIの上に構築されています。

MySQLdbをインストールする方法は？

先に進む前に、マシンにMySQLdbがインストールされていることを確認してください。 Pythonスクリプトに次を入力して実行するだけです-

#!/usr/bin/python

import MySQLdb

それは次の結果を生成する場合、それはMySQLdbモジュールがインストールされていないことを意味します-

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      import MySQLdb
ImportError: No module named MySQLdb

MySQLdbモジュールをインストールするには、次のコマンドを使用します-

For Ubuntu, use the following command -
$ sudo apt-get install python-pip python-dev libmysqlclient-dev
For Fedora, use the following command -
$ sudo dnf install python python-devel mysql-devel redhat-rpm-config gcc
For Python command prompt, use the following command -
pip install MySQL-python

注-上記のモジュールをインストールするためのルート権限があることを確認してください。

データベース接続

MySQLデータベースに接続する前に、次のことを確認してください-

• データベースTESTDBを作成しました。
• TESTDBにテーブルEMPLOYEEを作成しました。
• このテーブルには、FIRST_NAME、LAST_NAME、AGE、SEX、およびINCOMEフィールドがあります。
• ユーザーID「testuser」とパスワード「test123」は、TESTDBにアクセスするように設定されています。
• PythonモジュールMySQLdbがマシンに適切にインストールされます。
• リンクを理解するためにMySQLチュートリアルを完了しました：/mysql/index [MySQL Basics。]

例

以下は、MySQLデータベース「TESTDB」と接続する例です

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.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()

このスクリプトの実行中に、Linuxマシンで次の結果が生成されます。

Database version : 5.0.45

データソースとの接続が確立されると、接続オブジェクトが返され、さらに使用するために db に保存されます。それ以外の場合、 db はNoneに設定されます。 次に、 db オブジェクトを使用して cursor オブジェクトを作成し、これを使用してSQLクエリを実行します。 最後に、出てくる前に、データベース接続が閉じられ、リソースが解放されていることを確認します。

データベーステーブルの作成

データベース接続が確立されると、作成されたカーソルの execute メソッドを使用して、データベーステーブルにテーブルまたはレコードを作成する準備ができました。

例

データベーステーブルEMPLOYEEを作成しましょう-

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.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操作

データベーステーブルにレコードを作成する場合に必要です。

例

次の例では、SQL _INSERT_ステートメントを実行して、EMPLOYEEテーブルにレコードを作成します-

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.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/python

import MySQLdb

# Open database connection
db = MySQLdb.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/python

import MySQLdb

# Open database connection
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# prepare a cursor object using cursor() method
cursor = db.cursor()

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 fecth data"

# disconnect from server
db.close()

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

fname=Mac, lname=Mohan, age=20, sex=M, income=2000

更新操作

データベースでのUPDATE操作とは、データベースですでに使用可能な1つ以上のレコードを更新することです。

次の手順は、SEXが 'M' であるすべてのレコードを更新します。 ここでは、すべての男性の年齢を1年増やします。

例

#!/usr/bin/python

import MySQLdb

# Open database connection
db = MySQLdb.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/python

import MySQLdb

# Open database connection
db = MySQLdb.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-ネットワークプログラミング

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_モジュールで利用可能な_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/python           # This is server.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.
s.bind((host, port))        # Bind to the port

s.listen(5)                 # Now wait for client connection.
while True:
   c, addr = s.accept()     # Establish connection with client.
   print 'Got connection from', addr
   c.send('Thank you for connecting')
   c.close()                # Close the connection

シンプルなクライアント

特定のポート12345と特定のホストへの接続を開く、非常に単純なクライアントプログラムを作成してみましょう。 これは、Pythonの_socket_モジュール関数を使用してソケットクライアントを作成するのは非常に簡単です。

• socket.connect（hosname、port）*は、_port_上の_hostname_へのTCP接続を開きます。 ソケットを開いたら、IOオブジェクトのようにソケットから読み取ることができます。 完了したら、ファイルを閉じるのと同じように忘れずに閉じてください。

次のコードは、特定のホストとポートに接続し、ソケットから利用可能なデータを読み取り、終了する非常に単純なクライアントです-

#!/usr/bin/python           # This is client.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.

s.connect((host, port))
print s.recv(1024)
s.close()                     # Close the socket when done

次に、この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

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

Got connection from ('127.0.0.1', 48437)
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-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/python

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_メソッドをメッセージ、送信元アドレス、および宛先アドレスとともにパラメーターとして使用します（送信元アドレスと送信先アドレスはe -メール自体、これらは常にメールのルーティングに使用されるわけではありません）。

ローカルマシンでSMTPサーバーを実行していない場合は、_smtplib_クライアントを使用してリモートSMTPサーバーと通信できます。 Webメールサービス（HotmailやYahoo!など）を使用している場合を除きます メール）、あなたの電子メールプロバイダーは、次のように、それらを提供できる送信メールサーバーの詳細を提供している必要があります-

smtplib.SMTP('mail.your-domain.com', 25)

Pythonを使用してHTML電子メールを送信する

Pythonを使用してテキストメッセージを送信すると、すべてのコンテンツが単純なテキストとして扱われます。 テキストメッセージにHTMLタグを含めても、単純なテキストとして表示され、HTMLタグはHTML構文に従ってフォーマットされません。 しかし、PythonはHTMLメッセージを実際のHTMLメッセージとして送信するオプションを提供します。

電子メールメッセージの送信中に、MIMEバージョン、コンテンツタイプ、および文字セットを指定して、HTML電子メールを送信できます。

例

以下は、HTMLコンテンツを電子メールとして送信する例です。 一度試してください-

#!/usr/bin/python

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"）*関数でエンコードしてから、送信前にbase64エンコードする必要があります。

例

以下は、ファイル /tmp/test.txt を添付ファイルとして送信する例です。 一度試してください-

#!/usr/bin/python

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-マルチスレッドプログラミング

複数のスレッドを実行すると、複数の異なるプログラムを同時に実行することに似ていますが、次の利点があります-

• プロセス内の複数のスレッドはメインスレッドと同じデータ空間を共有するため、別々のプロセスである場合よりも簡単に情報を共有したり、相互に通信したりできます。
• スレッドはライトウェイトプロセスと呼ばれることもあり、多くのメモリオーバーヘッドを必要としません。プロセスよりも安価です。

スレッドには、開始、実行シーケンス、および結論があります。 コンテキスト内で現在実行されている場所を追跡する命令ポインターがあります。

• 先取り（中断）することができます
• 他のスレッドが実行されている間、一時的に保留（スリープとも呼ばれます）できます-これは、譲歩と呼ばれます。

新しいスレッドの開始

別のスレッドを生成するには、_thread_モジュールで利用可能な次のメソッドを呼び出す必要があります-

thread.start_new_thread ( function, args[, kwargs] )

このメソッド呼び出しにより、LinuxとWindowsの両方で新しいスレッドを高速かつ効率的に作成できます。

メソッド呼び出しはすぐに戻り、子スレッドが開始され、_args_の渡されたリストで関数を呼び出します。 関数が戻ると、スレッドは終了します。

ここで、_args_は引数のタプルです。引数を渡さずに関数を呼び出すには、空のタプルを使用します。 _kwargs_は、キーワード引数のオプションの辞書です。

例

#!/usr/bin/python

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: Thu Jan 22 15:42:17 2009
Thread-1: Thu Jan 22 15:42:19 2009
Thread-2: Thu Jan 22 15:42:19 2009
Thread-1: Thu Jan 22 15:42:21 2009
Thread-2: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:25 2009
Thread-2: Thu Jan 22 15:42:27 2009
Thread-2: Thu Jan 22 15:42:31 2009
Thread-2: Thu Jan 22 15:42:35 2009

低レベルのスレッド化には非常に効果的ですが、_thread_モジュールは新しいスレッド化モジュールに比べて非常に制限されています。

_Threading_モジュール

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（）メソッドは、スレッドの名前を設定します。

_Threading_モジュールを使用したスレッドの作成

スレッドモジュールを使用して新しいスレッドを実装するには、次を行う必要があります-

• _Thread_クラスの新しいサブクラスを定義します。
• _ init（self [、args]）_メソッドをオーバーライドして、引数を追加します。
• 次に、run（self [、args]）メソッドをオーバーライドして、開始時にスレッドが行うべきことを実装します。

新しい_Thread_サブクラスを作成したら、そのインスタンスを作成し、_start（）_を呼び出して新しいスレッドを開始し、_run（）_メソッドを呼び出します。

例

#!/usr/bin/python

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, 5, self.counter)
      print "Exiting " + self.name

def print_time(threadName, counter, delay):
   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()

print "Exiting Main Thread"

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

Starting Thread-1
Starting Thread-2
Exiting Main Thread
Thread-1: Thu Mar 21 09:10:03 2013
Thread-1: Thu Mar 21 09:10:04 2013
Thread-2: Thu Mar 21 09:10:04 2013
Thread-1: Thu Mar 21 09:10:05 2013
Thread-1: Thu Mar 21 09:10:06 2013
Thread-2: Thu Mar 21 09:10:06 2013
Thread-1: Thu Mar 21 09:10:07 2013
Exiting Thread-1
Thread-2: Thu Mar 21 09:10:08 2013
Thread-2: Thu Mar 21 09:10:10 2013
Thread-2: Thu Mar 21 09:10:12 2013
Exiting Thread-2

スレッドの同期

Pythonで提供されるスレッドモジュールには、スレッドを同期するための実装が簡単なロックメカニズムが含まれています。 新しいロックを返すには、_Lock（）_メソッドを呼び出して新しいロックを作成します。

新しいロックオブジェクトの_acquire（blocking）_メソッドは、スレッドを強制的に同期的に実行するために使用されます。 オプションの_blocking_パラメーターを使用すると、スレッドがロックの取得を待機するかどうかを制御できます。

_blocking_が0に設定されている場合、スレッドは、ロックを取得できない場合はすぐに0の値を返し、ロックが取得された場合は1を返します。 ブロックが1に設定されている場合、スレッドはブロックし、ロックが解除されるのを待ちます。

新しいロックオブジェクトの_release（）_メソッドは、不要になったときにロックを解除するために使用されます。

例

#!/usr/bin/python

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: Thu Mar 21 09:11:28 2013
Thread-1: Thu Mar 21 09:11:29 2013
Thread-1: Thu Mar 21 09:11:30 2013
Thread-2: Thu Mar 21 09:11:32 2013
Thread-2: Thu Mar 21 09:11:34 2013
Thread-2: Thu Mar 21 09:11:36 2013
Exiting Main Thread

マルチスレッドプライオリティキュー

_Queue_モジュールを使用すると、特定の数のアイテムを保持できる新しいキューオブジェクトを作成できます。 キューを制御するには、次の方法があります-

• * get（）*-get（）は、キューからアイテムを削除して返します。
• * put（）*-putは、アイテムをキューに追加します。
• * qsize（）*-qsize（）は、現在キューにあるアイテムの数を返します。
• * empty（）*-empty（）は、キューが空の場合にTrueを返します。それ以外の場合、False。
• * full（）*-キューがいっぱいの場合、full（）はTrueを返します。それ以外の場合、False。

例

#!/usr/bin/python

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-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）*-ここでは、目的のイベントのコールバックを登録し、パーサーにドキュメントを処理させます。 これは、ドキュメントが大きい場合やメモリに制限がある場合に便利です。ファイルをディスクから読み取って解析し、ファイル全体がメモリに保存されることはありません。
• Document Object Model（DOM）API -これはWorld Wide Web Consortiumの推奨事項であり、ファイル全体がメモリに読み込まれ、XMLドキュメントのすべての機能を表す階層（ツリーベース）形式で保存されます。

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メソッドをすべて実装する必要がある、使用するパーサーのリストで構成されるオプションの引数。

_parse_メソッド

次のメソッドは、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/python

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 schientific 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ドキュメントの詳細については、標準のhttp://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/python

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 schientific 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ドキュメントの詳細については、標準のhttp://docs.python.org/library/xml.doml[Python DOM APIs]を参照してください。

Python-GUIプログラミング（Tkinter）

Pythonは、グラフィカルユーザーインターフェイス（GUI）を開発するためのさまざまなオプションを提供します。 最も重要なものを以下にリストします。

• Tkinter -Tkinterは、Pythonに付属のTk GUIツールキットへのPythonインターフェイスです。 この章では、このオプションを検討します。
• wxPython -これはwxWindows [[2]]
• 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/python

import Tkinter
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 このモジュールは、アプリケーションでメッセージボックスを表示するために使用されます。

これらのウィジェットを詳細に調べてみましょう-

標準属性

サイズ、色、フォントなどの共通の属性がどのように指定されているかを見てみましょう。

• リンク：/python/tk_dimensions [寸法]
• リンク：/python/tk_colors [色]
• リンク：/python/tk_fonts [フォント]
• リンク：/python/tk_anchors [アンカー]
• リンク：/python/tk_relief [レリーフスタイル]
• リンク：/python/tk_bitmaps [ビットマップ]
• リンク：/python/tk_cursors [カーソル]

それらを簡単に研究しましょう-

ジオメトリ管理

すべてのTkinterウィジェットは、特定のジオメトリ管理メソッドにアクセスできます。これには、親ウィジェットエリア全体でウィジェットを整理する目的があります。 Tkinterは、pack、grid、およびplaceのジオメトリマネージャークラスを公開します。

• link：/python/tk_pack [The pack（） Method]-このジオメトリマネージャーは、ウィジェットを親ウィジェットに配置する前にブロックに編成します。
• link：/python/tk_grid [The grid（） Method]-このジオメトリマネージャは、ウィジェットを親ウィジェットのテーブルのような構造に編成します。
• link：/python/tk_place [The place（） Method]-このジオメトリマネージャは、ウィジェットを親ウィジェット内の特定の位置に配置することでウィジェットを整理します。

ジオメトリ管理方法を簡単に研究しましょう-

Python-Cを使用した拡張プログラミング

C、C ++、Javaなどのコンパイル済み言語を使用して記述したコードは、別のPythonスクリプトに統合またはインポートできます。 このコードは「拡張機能」と見なされます。

Python拡張モジュールは、通常のCライブラリにすぎません。 Unixマシンでは、これらのライブラリは通常 .so （共有オブジェクト用）で終わります。 Windowsマシンでは、通常、*。dll *（動的にリンクされたライブラリ用）が表示されます。

拡張機能を記述するための前提条件

拡張機能の作成を開始するには、Pythonヘッダーファイルが必要になります。

• Unixマシンでは、通常、http：//packages.debian.org/etch-m68k/python2.5-dev [python2.5-dev]などの開発者固有のパッケージをインストールする必要があります。
• Windowsユーザーは、バイナリPythonインストーラーを使用すると、パッケージの一部としてこれらのヘッダーを取得します。

さらに、Cプログラミングを使用してPython拡張機能を作成するには、CまたはC ++の十分な知識があることが前提となります。

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_と呼ばれるセットアップスクリプトを介してビルドおよびインストールされます。

上記のモジュールでは、次の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/python
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*+int	Any Python string to C address and length.
t#	char*+int	Read-only single-segment buffer to C address and length.
u	Py_UNICODE*	Python Unicode without embedded nulls to C.
u#	Py_UNICODE*+int	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&	convert+void*	Arbitrary conversion
s	char*	C 0-terminated char* to Python string, or NULL to None.
s#	char*+int	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*+int	C-wide string and length to Python Unicode, or NULL to None.
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 …​	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}のような辞書を返します。 Python-questions-answers

Pythonツール/ユーティリティ

標準ライブラリには、モジュールとしてもコマンドラインユーティリティとしても使用できる多数のモジュールが付属しています。

_dis_モジュール

disモジュールはPython逆アセンブラーです。 バイトコードを、人間が消費するのにやや適した形式に変換します。

コマンドラインから逆アセンブラを実行できます。 指定されたスクリプトをコンパイルし、逆アセンブルされたバイトコードをSTDOUTに出力します。 disをモジュールとして使用することもできます。 dis 関数は、クラス、メソッド、関数、またはコードオブジェクトを単一の引数として受け取ります。

例

#!/usr/bin/python
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/python

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/python

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.