Pythonクイックガイド

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

• Python is Interpreted− Pythonは、実行時にインタプリタによって処理されます。プログラムを実行する前に、プログラムをコンパイルする必要はありません。これはPERLやPHPに似ています。

• Python is Interactive −実際にはPythonプロンプトに座って、インタプリタと直接対話してプログラムを作成できます。

• Python is Object-Oriented − Pythonは、オブジェクト内にコードをカプセル化するオブジェクト指向のスタイルまたはプログラミング手法をサポートしています。

• Python is a Beginner's Language − Pythonは初心者レベルのプログラマーにとって優れた言語であり、単純なテキスト処理からWWWブラウザー、ゲームまで、幅広いアプリケーションの開発をサポートします。

Pythonの歴史

Pythonは、80年代後半から90年代初頭に、オランダの国立数学情報科学研究所でGuido vanRossumによって開発されました。

Pythonは、ABC、Modula-3、C、C ++、Algol-68、SmallTalk、Unixシェル、その他のスクリプト言語など、他の多くの言語から派生しています。

Pythonは著作権で保護されています。Perlと同様に、PythonソースコードはGNU General Public License（GPL）の下で利用できるようになりました。

Pythonは現在、研究所のコア開発チームによって保守されていますが、Guido vanRossumはその進歩を指揮する上で依然として重要な役割を果たしています。

Pythonの機能

Pythonの機能は次のとおりです。

• Easy-to-learn− Pythonには、キーワードがほとんどなく、構造が単純で、構文が明確に定義されています。これにより、生徒は言語をすばやく習得できます。

• Easy-to-read − Pythonコードはより明確に定義され、目に見えます。

• Easy-to-maintain −Pythonのソースコードは保守がかなり簡単です。

• A broad standard library − Pythonのライブラリの大部分は、UNIX、Windows、およびMacintoshで非常に移植性が高く、クロスプラットフォーム互換です。

• Interactive Mode − Pythonは、コードスニペットのインタラクティブなテストとデバッグを可能にするインタラクティブモードをサポートしています。

• Portable − Pythonは、さまざまなハードウェアプラットフォームで実行でき、すべてのプラットフォームで同じインターフェイスを備えています。

• Extendable−Pythonインタープリターに低レベルのモジュールを追加できます。これらのモジュールを使用すると、プログラマーはツールを追加またはカスタマイズして、より効率的にすることができます。

• Databases − Pythonは、すべての主要な商用データベースへのインターフェイスを提供します。

• GUI Programming − Pythonは、作成して、Windows MFC、Macintosh、UnixのX Windowシステムなど、多くのシステムコール、ライブラリ、Windowsシステムに移植できるGUIアプリケーションをサポートしています。

• Scalable − Pythonは、シェルスクリプトよりも優れた構造と大規模プログラムのサポートを提供します。

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

• 関数型および構造化プログラミング手法とOOPをサポートします。

• スクリプト言語として使用することも、大規模なアプリケーションを構築するためにバイトコードにコンパイルすることもできます。

• 非常に高レベルの動的データ型を提供し、動的型チェックをサポートします。

• 自動ガベージコレクションをサポートします。

• C、C ++、COM、ActiveX、CORBA、およびJavaと簡単に統合できます。

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

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

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

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

Pythonの入手

最新かつ最新のソースコード、バイナリ、ドキュメント、ニュースなどは、Pythonの公式Webサイトで入手できます。 https://www.python.org/

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形式のソースコードをダウンロードします。

• ファイルをダウンロードして抽出します。

• 一部のオプションをカスタマイズする場合は、モジュール/セットアップファイルを編集します。

• ./configureスクリプトを実行します

• make

• インストールする

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

Windowsのインストール

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

• Webブラウザーを開き、 https://www.python.org/downloads/。

• XYZがインストールする必要のあるバージョンであるWindowsインストーラーpython-XYZ.msiファイルのリンクをたどります。

• このインストーラーpython-XYZ.msiを使用するには、WindowsシステムがMicrosoftインストーラー2.0をサポートしている必要があります。インストーラーファイルをローカルマシンに保存してから実行し、マシンがMSIをサポートしているかどうかを確認します。

• ダウンロードしたファイルを実行します。これにより、Pythonインストールウィザードが表示されます。これは非常に使いやすいです。デフォルト設定を受け入れ、インストールが完了するまで待つだけで完了です。

Macintoshのインストール

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

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

PATHの設定

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

パスは、オペレーティングシステムによって維持される名前付き文字列である環境変数に格納されます。この変数には、コマンドシェルやその他のプログラムで利用できる情報が含まれています。

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

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

Unix / Linuxでのパスの設定

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

• In the csh shell − setenv PATH "$ PATH：/ usr / local / bin / python"と入力し、Enterキーを押します。

• In the bash shell (Linux) − export PATH = "$ PATH：/ usr / local / bin / python"と入力し、Enterキーを押します。

• In the sh or ksh shell − PATH = "$ PATH：/ usr / local / bin / python"と入力し、Enterキーを押します。

• Note − / usr / local / bin / pythonはPythonディレクトリのパスです

Windowsでパスを設定する

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

At the command prompt − path％path％; C：\ Pythonと入力し、Enterキーを押します。

Note − c：\ PythonはPythonディレクトリのパスです

Python環境変数

Pythonで認識できる重要な環境変数は次のとおりです-

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

Pythonの実行

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

インタラクティブ通訳

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

入る python コマンドライン。

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

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

使用可能なすべてのコマンドラインオプションのリストは次のとおりです-

シニア番号	オプションと説明
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

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

統合開発環境

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

• Unix − IDLEは、Python用の最初のUnixIDEです。

• Windows − PythonWinは、Python用の最初のWindowsインターフェイスであり、GUIを備えたIDEです。

• Macintosh −MacintoshバージョンのPythonとIDLEIDEは、メインのWebサイトから入手でき、MacBinaryファイルまたはBinHexファイルとしてダウンロードできます。

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

Note −以降の章に記載されているすべての例は、LinuxのCentOSフレーバーで利用可能なPython2.4.3バージョンで実行されています。

理論を学習しているときに、利用可能なすべての例をオンラインで同時に実行できるように、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ステートメントを使用する必要があります。 print ("Hello, Python!");。ただし、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!"

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

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

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

Hello, Python!

Python識別子

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

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

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

• クラス名は大文字で始まります。他のすべての識別子は小文字で始まります。

• 単一の先頭の下線で識別子を開始すると、識別子がプライベートであることを示します。

• 2つの先頭の下線で識別子を開始すると、厳密にプライベートな識別子を示します。

• 識別子の末尾に2つのアンダースコアも付いている場合、その識別子は言語で定義された特別な名前です。

予約語

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

そして	exec	ない
主張する	最終的に	または
ブレーク	にとって	パス
クラス	から	印刷
継続する	グローバル	上げる
def	もし	戻る
デル	インポート	試してみてください
エリフ	に	一方
そうしないと	です	と
を除いて	ラムダ	産出

線とインデント

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

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

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

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

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

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

Note−この時点ではロジックを理解しようとしないでください。中かっこがなくても、さまざまなブロックを理解していることを確認してください。

#!/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はそれを完全に無視します。

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

ユーザーを待っています

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

#!/usr/bin/python

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

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

1行に複数のステートメント

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

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

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

単一のコードブロックを作成する個々のステートメントのグループは、 suitesPythonで。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. ]

さまざまなオプションを受け入れるようにスクリプトをプログラムすることもできます。コマンドライン引数は高度なトピックであり、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つの標準データ型があります-

• Numbers
• String
• List
• Tuple
• Dictionary

Python番号

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

var1 = 1
var2 = 10

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

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

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

del var
del var_a, var_b

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

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

例

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

int	長いです	浮く	繁雑
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タプル

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

リストとタプルの主な違いは次のとおりです。リストは角かっこ（[]）で囲まれ、要素とサイズは変更できますが、タプルは括弧（（））で囲まれ、更新できません。タプルは次のように考えることができますread-onlyリスト。例-

#!/usr/bin/python

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

print tuple               # Prints the complete tuple
print tuple[0]            # Prints first element of the tuple
print tuple[1:3]          # Prints elements of the tuple starting from 2nd till 3rd 
print tuple[2:]           # Prints elements of the tuple starting from 3rd element
print tinytuple * 2       # Prints the contents of the tuple twice
print tuple + tinytuple   # Prints concatenated tuples

これにより、次の結果が得られます-

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

辞書には、要素間の順序の概念がありません。要素が「故障している」と言うのは誤りです。それらは単に順序付けられていません。

データ型変換

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

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

シニア番号	機能と説明
1	int(x [,base]) xを整数に変換します。xが文字列の場合、baseはベースを指定します。
2	long(x [,base] ) xを長整数に変換します。xが文字列の場合、baseはベースを指定します。
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は、（キー、値）タプルのシーケンスである必要があります。
12	frozenset(s) sをフリーズセットに変換します。
13	chr(x) 整数を文字に変換します。
14	unichr(x) 整数をUnicode文字に変換します。
15	ord(x) 単一の文字をその整数値に変換します。
16	hex(x) 整数を16進文字列に変換します。
17	oct(x) 整数を8進文字列に変換します。

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

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

オペレーターの種類

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

• 算術演算子
• 比較（関係）演算子
• 代入演算子
• 論理演算子
• ビット演算子
• メンバーシップオペレーター
• アイデンティティ演算子

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

Python算術演算子

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

[例を表示]

オペレーター	説明	例
+追加	演算子のいずれかの側に値を追加します。	a + b = 30
-減算	左側のオペランドから右側のオペランドを減算します。	a – b = -10
*乗算	演算子のいずれかの側で値を乗算します	a * b = 200
/部門	左側のオペランドを右側のオペランドで除算します	b / a = 2
％ 係数	左側のオペランドを右側のオペランドで除算し、余りを返します	b％a = 0
**指数	演算子の指数（パワー）計算を実行します	a ** b = 10の20乗
//	フロア分割-結果が小数点以下の桁を削除した商であるオペランドの分割。ただし、オペランドの1つが負の場合、結果はフロアになります。つまり、ゼロから丸められます（負の無限大に向かって）-	9 // 2 = 4および9.0 // 2.0 = 4.0、-11 // 3 = -4、-11.0 // 3 = -4.0

Python比較演算子

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

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

[例を表示]

オペレーター	説明	例
==	2つのオペランドの値が等しい場合、条件は真になります。	（a == b）は真ではありません。
！=	2つのオペランドの値が等しくない場合、条件は真になります。	（a！= b）は真です。
<>	2つのオペランドの値が等しくない場合、条件は真になります。	（a <> b）は真です。これは！=演算子に似ています。
>>	左のオペランドの値が右のオペランドの値より大きい場合、条件は真になります。	（a> b）は正しくありません。
<	左のオペランドの値が右のオペランドの値よりも小さい場合、条件は真になります。	（a <b）は真です。
> =	左のオペランドの値が右のオペランドの値以上の場合、条件は真になります。	（a> = b）は正しくありません。
<=	左のオペランドの値が右のオペランドの値以下の場合、条件は真になります。	（a <= b）は真です。

Python代入演算子

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

[例を表示]

オペレーター	説明	例
=	右側のオペランドから左側のオペランドに値を割り当てます	c = a + bは、a + bの値をcに割り当てます
+ = ANDを追加	右のオペランドを左のオペランドに追加し、結果を左のオペランドに割り当てます	c + = aはc = c + aと同等です
-= ANDを引く	左のオペランドから右のオペランドを減算し、その結果を左のオペランドに割り当てます	c- = aはc = c-aと同等です
* = ANDを掛ける	右のオペランドと左のオペランドを乗算し、その結果を左のオペランドに割り当てます。	c * = aはc = c * aと同等です
/ =分割統治法	左のオペランドを右のオペランドで除算し、その結果を左のオペランドに割り当てます	c / = aはc = c / aと同等です
％=モジュラスAND	2つのオペランドを使用してモジュラスを取り、その結果を左のオペランドに割り当てます。	c％= aはc = c％aと同等です
** =指数AND	演算子に対して指数（累乗）計算を実行し、左側のオペランドに値を割り当てます	c ** = aはc = c ** aと同等です
// =フロア分割	演算子のフロア除算を実行し、左側のオペランドに値を割り当てます	c // = aはc = c // aと同等です

Pythonビット演算子

ビット単位の演算子はビットを処理し、ビットごとの演算を実行します。a = 60の場合を想定します。およびb = 13; バイナリ形式では、値はそれぞれ00111100と00001101になります。次の表に、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言語でサポートされている次のビット演算子があります

[例を表示]

オペレーター	説明	例
＆バイナリAND	演算子が両方のオペランドに存在する場合、結果にビットをコピーします	（a＆b）（0000 1100を意味します）
| バイナリOR	いずれかのオペランドに存在する場合は、ビットをコピーします。	（a | b）= 61（0011 1101を意味します）
^バイナリXOR	両方ではなく一方のオペランドに設定されている場合、ビットをコピーします。	（a ^ b）= 49（0011 0001を意味します）
〜バイナリの補数	これは単項であり、ビットを「反転」させる効果があります。	（〜a）= -61（符号付き2進数のため、2の補数形式の11000011を意味します。
<<バイナリ左シフト	左のオペランドの値は、右のオペランドで指定されたビット数だけ左に移動します。	a << 2 = 240（1111 0000を意味します）
>>バイナリ右シフト	左のオペランドの値は、右のオペランドで指定されたビット数だけ右に移動します。	a >> 2 = 15（0000 1111を意味します）

Python論理演算子

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

[例を表示]

オペレーター	説明	例
および論理積	両方のオペランドが真の場合、条件は真になります。	（aとb）は真です。
または論理OR	2つのオペランドのいずれかがゼロ以外の場合、条件は真になります。	（aまたはb）は真です。
論理的ではないNOT	オペランドの論理状態を逆にするために使用されます。	Not（aおよびb）はfalseです。

Pythonメンバーシップ演算子

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

[例を表示]

オペレーター	説明	例
に	指定されたシーケンスで変数が見つかった場合はtrueと評価され、それ以外の場合はfalseと評価されます。	x in y、ここでは、xがシーケンスyのメンバーである場合、結果は1になります。
ありませんで	指定されたシーケンスで変数が見つからない場合はtrueと評価され、それ以外の場合はfalseと評価されます。	xがyにない場合、xがシーケンスyのメンバーでない場合、ここでは1になりません。

PythonID演算子

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

[例を表示]

オペレーター	説明	例
です	演算子のいずれかの側の変数が同じオブジェクトを指している場合はtrueと評価され、そうでない場合はfalseと評価されます。	xはy、ここ is id（x）がid（y）と等しい場合、結果は1になります。
ではありません	演算子のいずれかの側の変数が同じオブジェクトを指している場合はfalseと評価され、それ以外の場合はtrueと評価されます。	xはyではありません、ここ is not id（x）がid（y）と等しくない場合、結果は1になります。

Python演算子の優先順位

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

[例を表示]

シニア番号	オペレーターと説明
1	** べき乗（累乗）
2	~ + - 補数、単項プラスおよびマイナス（最後の2つのメソッド名は+ @および-@です）
3	* / % // 乗算、除算、モジュロおよびフロア除算
4	+ - 足し算と引き算
5	>> << 左右のビット単位のシフト
6	& ビット単位の「AND」
7	^ | ビット単位の排他的論理和と通常の論理和
8	<= < > >= 比較演算子
9	<> == != 等式演算子
10	= %= /= //= -= += *= **= 代入演算子
11	is is not ID演算子
12	in not in メンバーシップオペレーター
13	not or and 論理演算子

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

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

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

Pythonプログラミング言語は non-zero そして non-null 値はTRUEであり、どちらかである場合 zero または nullの場合、FALSE値と見なされます。

Pythonプログラミング言語は、次のタイプの意思決定ステートメントを提供します。詳細を確認するには、次のリンクをクリックしてください。

シニア番号	ステートメントと説明
1	ifステートメント アン if statement ブール式とそれに続く1つ以上のステートメントで構成されます。
2	if ... elseステートメント アン if statement オプションの後に続くことができます else statement、ブール式がFALSEの場合に実行されます。
3	ネストされたifステートメント あなたは1つを使用することができます if または else if statement inside another if or else if statement(s).

Let us go through each decision making briefly −

Single Statement Suites

If the suite of an if clause consists only of a single line, it may go on the same line as the header statement.

Here is an example of a one-line if clause −

#!/usr/bin/python

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

When the above code is executed, it produces the following result −

Value of expression is 100
Good bye!

In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on. There may be a situation when you need to execute a block of code several number of times.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times. The following diagram illustrates a loop statement −

Python programming language provides following types of loops to handle looping requirements.

Sr.No.	Loop Type & Description
1	while loop Repeats a statement or group of statements while a given condition is TRUE. It tests the condition before executing the loop body.
2	for loop Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.
3	nested loops You can use one or more loop inside any another while, for or do..while loop.

Loop Control Statements

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

Python supports the following control statements. Click the following links to check their detail.

Let us go through the loop control statements briefly

Sr.No.	Control Statement & Description
1	break statement Terminates the loop statement and transfers execution to the statement immediately following the loop.
2	continue statement Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
3	pass statement The pass statement in Python is used when a statement is required syntactically but you do not want any command or code to execute.

Number data types store numeric values. They are immutable data types, means that changing the value of a number data type results in a newly allocated object.

Number objects are created when you assign a value to them. For example −

var1 = 1
var2 = 10

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

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

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

del var
del var_a, var_b

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

• int (signed integers) −これらはしばしば整数または整数と呼ばれ、小数点のない正または負の整数です。

• long (long integers ) − longとも呼ばれ、サイズに制限のない整数であり、整数のように記述され、その後に大文字または小文字のLが続きます。

• float (floating point real values)−フロートとも呼ばれ、実数を表し、整数部分と小数部分を分割する小数点で記述されます。フロートは科学的記数法である場合もあり、Eまたはeは10の累乗を示します（2.5e2 = 2.5 x 10 ² = 250）。

• complex (complex numbers)−はa + bJの形式です。ここで、aとbは浮動小数点数であり、J（またはj）は-1（虚数）の平方根を表します。数の実数部はaで、虚数部はbです。Pythonプログラミングでは、複素数はあまり使用されません。

例

これが数字の例です

int	長いです	浮く	繁雑
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は、混合型を含む式の内部で数値を評価用の共通型に変換します。ただし、演​​算子または関数パラメーターの要件を満たすために、ある型から別の型に明示的に数値を強制変換する必要がある場合があります。

• タイプ int(x) xを単純な整数に変換します。

• タイプ long(x) xを長整数に変換します。

• タイプ float(x) xを浮動小数点数に変換します。

• タイプ complex(x) xを実数部xと虚数部ゼロの複素数に変換します。

• タイプ complex(x, y)xとyを実数部xと虚数部yの複素数に変換します。xとyは数式です

数学関数

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

シニア番号	関数と戻り値（説明）
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	床（x） xのフロア：x以下の最大の整数
7	log（x） x> 0の場合の、xの自然対数
8	log10（x） x> 0の場合のxの常用対数。
9	max（x1、x2、...） その引数の最大のもの：正の無限大に最も近い値
10	min（x1、x2、...） その引数の最小値：負の無限大に最も近い値
11	modf（x） 2項目タプルのxの小数部と整数部。両方の部分はxと同じ符号を持っています。整数部分はfloatとして返されます。
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には、一般的に使用される次の関数が含まれています。

シニア番号	機能と説明
1	choice（seq） リスト、タプル、または文字列からのランダムなアイテム。
2	randrange（[start、] stop [、step]） range（start、stop、step）からランダムに選択された要素
3	ランダム（） 0がr以下で、rが1未満であるようなランダムフロートr
4	シード（[x]） 乱数の生成に使用される整数の開始値を設定します。他のランダムモジュール関数を呼び出す前に、この関数を呼び出してください。Noneを返します。
5	シャッフル（lst） リストのアイテムを所定の位置にランダム化します。Noneを返します。
6	ユニフォーム（x、y） xがr以下で、rがy未満であるようなランダムフロートr

三角関数

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

シニア番号	機能と説明
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	度（x） 角度xをラジアンから度に変換します。
10	ラジアン（x） 角度xを度からラジアンに変換します。

数学定数

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

シニア番号	定数と説明
1	pi 数学定数pi。
2	e 数学的定数e。

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

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

文字列の値へのアクセス

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

部分文字列にアクセスするには、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

エスケープ文字

次の表は、円記号で表すことができるエスケープ文字または印刷不可能な文字のリストです。

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

バックスラッシュ表記	16進文字	説明
\ a	0x07	ベルまたはアラート
\ b	0x08	バックスペース
\ cx		Control-x
\ Cx		Control-x
\ e	0x1b	逃れる
\ f	0x0c	フォームフィード
\ M- \ Cx		Meta-Control-x
\ n	0x0a	改行
\ nnn		nが0.7の範囲にある8進表記
\ r	0x0d	キャリッジリターン
\ s	0x20	スペース
\ t	0x09	タブ
\ v	0x0b	垂直タブ
\バツ		文字x
\ xnn		nが0.9、af、またはAFの範囲にある16進表記

文字列特殊演算子

文字列変数を想定 a 'Hello'と変数を保持します b 'Python'を保持し、次に−

オペレーター	説明	例
+	連結-演算子のいずれかの側に値を追加します	a + bはHelloPythonを与えます
*	繰り返し-同じ文字列の複数のコピーを連結して、新しい文字列を作成します	a * 2は-HelloHelloを与えます
[]	スライス-指定されたインデックスから文字を与えます	a [1]はeを与えます
[：]	範囲スライス-指定された範囲の文字を指定します	a [1：4]はエルを与える
に	メンバーシップ-指定された文字列に文字が存在する場合はtrueを返します	のHは1を与えます
ありませんで	メンバーシップ-指定された文字列に文字が存在しない場合はtrueを返します	意志のないMは1を与える
r / R	生の文字列-エスケープ文字の実際の意味を抑制します。生の文字列の構文は、生の文字列演算子である引用符の前にある文字「r」を除いて、通常の文字列とまったく同じです。「r」は小文字（r）または大文字（R）にすることができ、最初の引用符の直前に配置する必要があります。	印刷r '\ n'は\ nを印刷し、R '\ n'は印刷\ n
％	フォーマット-文字列フォーマットを実行します	次のセクションを参照してください

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

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!

これは、％−と一緒に使用できる記号の完全なセットのリストです。

フォーマット記号	変換
％c	キャラクター
％s	フォーマット前のstr（）による文字列変換
％私	符号付き10進整数
％d	符号付き10進整数
％u	符号なし10進整数
％o	8進整数
％バツ	16進整数（小文字）
％バツ	16進整数（大文字）
％e	指数表記（小文字の「e」付き）
％E	指数表記（大文字の「E」付き）
％f	浮動小数点実数
％g	％fと％eの短い方
％G	％fと％Eの短い方

サポートされているその他の記号と機能を次の表に示します。

シンボル	機能性
*	引数は幅または精度を指定します
-	左揃え
+	サインを表示する
<sp>	正の数の前に空白を残します
＃	'x'または 'X'のどちらが使用されたかに応じて、8進数の先行ゼロ（ '0'）または16進数の先行 '0x'または '0X'を追加します。
0	左からゼロで埋める（スペースの代わりに）
％	'%%'は、単一のリテラル '％'を残します
（var）	マッピング変数（辞書引数）
mn	mは最小合計幅、nは小数点以下に表示する桁数です（該当する場合）。

トリプルクォート

Pythonの三重引用符は、文字列が逐語的なNEWLINE、TAB、およびその他の特殊文字を含む複数の行にまたがることを可能にすることによって救いの手を差し伸べます。

三重引用符の構文は、3つの連続したもので構成されます single or double 引用符。

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

上記のコードを実行すると、次のような結果になります。「上」の間の文字列の最後にある最後のNEWLINEまで、すべての特殊文字がどのように印刷された形式に変換されたかに注意してください。三重引用符を閉じます。また、NEWLINEは、行末の明示的なキャリッジリターンまたはそのエスケープコード（\ 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!

ご覧のとおり、生の文字列がプレフィックスrを使用するのと同じように、Unicode文字列はプレフィックスuを使用します。

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

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

シニア番号	説明付きのメソッド
1	Capitalize（） 文字列の最初の文字を大文字にします
2	center（width、fillchar） 元の文字列が幅の列の合計の中央に配置された、スペースが埋め込まれた文字列を返します。
3	count（str、beg = 0、end = len（string）） 開始インデックスbegと終了インデックスendが指定されている場合、strが文字列または文字列の部分文字列で発生する回数をカウントします。
4	decode（encoding = 'UTF-8'、errors = 'strict'） エンコード用に登録されたコーデックを使用して文字列をデコードします。エンコーディングはデフォルトでデフォルトの文字列エンコーディングになります。
5	encode（encoding = 'UTF-8'、errors = 'strict'） 文字列のエンコードされた文字列バージョンを返します。エラーの場合、デフォルトでは、「ignore」または「replace」でエラーが発生しない限り、ValueErrorが発生します。
6	extendswith（suffix、beg = 0、end = len（string）） 文字列または文字列の部分文字列（開始インデックスbegと終了インデックスendが指定されている場合）が接尾辞で終わるかどうかを決定します。その場合はtrueを返し、そうでない場合はfalseを返します。
7	expandtabs（tabsize = 8） 文字列内のタブを複数のスペースに展開します。tabsizeが指定されていない場合、デフォルトでタブごとに8スペースになります。
8	find（str、beg = 0 end = len（string）） 開始インデックスbegと終了インデックスendが指定されている場合、strが文字列で発生するか、文字列のサブストリングで発生するかを判別します。見つかった場合はインデックスを返し、それ以外の場合は-1を返します。
9	index（str、beg = 0、end = len（string）） 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（文字列） 文字列の長さを返します
20	ljust（width [、fillchar]） 元の文字列が幅の列の合計に左寄せされた、スペースが埋め込まれた文字列を返します。
21	lower（） 文字列内のすべての大文字を小文字に変換します。
22	lstrip（） 文字列の先頭の空白をすべて削除します。
23	maketrans（） 変換関数で使用される変換テーブルを返します。
24	max（str） 文字列strから最大アルファベット文字を返します。
25	min（str） 文字列strから最小アルファベット文字を返します。
26	replace（old、new [、max]） 文字列内の古いオカレンスをすべて新しいオカレンスに置き換えます。maxが指定されている場合は最大で最大オカレンスに置き換えます。
27	rfind（str、beg = 0、end = len（string）） find（）と同じですが、文字列を逆方向に検索します。
28	rindex（str、beg = 0、end = len（string）） index（）と同じですが、文字列を逆方向に検索します。
29	rjust（width、[、fillchar]） スペースが埋め込まれた文字列を返します。元の文字列は、幅の列の合計に右寄せされます。
30	rstrip（） 文字列の末尾の空白をすべて削除します。
31	split（str = ""、num = string.count（str）） 区切り文字str（指定されていない場合はスペース）に従って文字列を分割し、部分文字列のリストを返します。与えられた場合、最大でnum個の部分文字列に分割します。
32	splitlines（num = string.count（ '\ n'）） 文字列をすべて（またはnum）のNEWLINEで分割し、NEWLINEを削除した各行のリストを返します。
33	startwith（str、beg = 0、end = len（string）） 文字列または文字列の部分文字列（開始インデックスbegと終了インデックスendが指定されている場合）が部分文字列strで始まるかどうかを決定します。その場合はtrueを返し、そうでない場合はfalseを返します。
34	strip（[chars]） 文字列に対してlstrip（）とrstrip（）の両方を実行します。
35	swapcase（） 文字列内のすべての文字の大文字と小文字を反転します。
36	題名（） 文字列の「タイトル付き」バージョンを返します。つまり、すべての単語は大文字で始まり、残りは小文字です。
37	translate（table、deletechars = ""） 変換テーブルstr（256 chars）に従って文字列を変換し、del文字列内の文字列を削除します。
38	アッパー（） 文字列内の小文字を大文字に変換します。
39	zfill（幅） ゼロが左に埋め込まれた元の文字列を合計幅の文字に返します。数値を対象としたzfill（）は、指定された任意の符号（ゼロが1つ未満）を保持します。
40	isdecimal（） Unicode文字列に10進文字のみが含まれている場合はtrueを返し、それ以外の場合はfalseを返します。

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から始まり、リストはスライス、連結などが可能です。

リスト内の値へのアクセス

リスト内の値にアクセスするには、1つまたは複数のインデックスとともにスライスするための角括弧を使用して、そのインデックスで使用可能な値を取得します。例-

#!/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]

Note − 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]

Note − remove（）メソッドについては、次のセクションで説明します。

基本的なリスト操作

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

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

Python式	結果	説明
len（[1、2、3]）	3	長さ
[1、2、3] + [4、5、6]	[1、2、3、4、5、6]	連結
['こんにちは！'] * 4	['Hi！'、 'Hi！'、 'Hi！'、 'Hi！']	繰り返し
[1、2、3]の3	本当	メンバーシップ
[1、2、3]のxの場合：印刷x、	1 2 3	反復

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

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

次の入力を想定-

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

Python式	結果	説明
L [2]	スパム！	オフセットはゼロから始まります
L [-2]	スパム	ネガティブ：右から数える
L [1：]	['スパム'、 'SPAM！']	スライスはセクションをフェッチします

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

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

シニア番号	説明付きの関数
1	cmp（list1、list2） 両方のリストの要素を比較します。
2	len（リスト） リストの全長を示します。
3	max（list） リストから最大値のアイテムを返します。
4	min（リスト） 最小値でリストからアイテムを返します。
5	list（seq） タプルをリストに変換します。

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

シニア番号	説明付きのメソッド
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]） リストのオブジェクトを並べ替えます。指定されている場合はcomparefuncを使用します

タプルは、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式	結果	説明
len（（1、2、3））	3	長さ
（1、2、3）+（4、5、6）	（1、2、3、4、5、6）	連結
（ 'こんにちは！'、）* 4	（「Hi！」、「Hi！」、「Hi！」、「Hi！」）	繰り返し
3インチ（1、2、3）	本当	メンバーシップ
（1、2、3）のxの場合：印刷x、	1 2 3	反復

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

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

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

 

Python式	結果	説明
L [2]	'スパム！'	オフセットはゼロから始まります
L [-2]	'スパム'	ネガティブ：右から数える
L [1：]	['スパム'、 'SPAM！']	スライスはセクションをフェッチします

区切り文字なし

これらの短い例に示されているように、コンマで区切られ、記号を識別せずに記述された複数のオブジェクトのセット（リストの角かっこ、タプルの括弧など）は、デフォルトでタプルになります。

#!/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には次のタプル関数が含まれています-

シニア番号	説明付きの関数
1	cmp（tuple1、tuple2） 両方のタプルの要素を比較します。
2	len（タプル） タプルの全長を示します。
3	max（タプル） 最大値を持つタプルからアイテムを返します。
4	min（タプル） 最小値を持つタプルからアイテムを返します。
5	タプル（seq） リストをタプルに変換します。

各キーはコロン（:)で値から区切られ、項目はコンマで区切られ、全体が中括弧で囲まれます。アイテムのない空の辞書は、次のように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']

これにより、次の結果が得られます。後に例外が発生することに注意してくださいdel dict 辞書はもう存在しません-

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

Note − 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には次の辞書関数が含まれています-

シニア番号	説明付きの関数
1	cmp（dict1、dict2） 両方のdictの要素を比較します。
2	len（dict） 辞書の全長を示します。これは、辞書内のアイテムの数と同じになります。
3	str（dict） 辞書の印刷可能な文字列表現を生成します
4	タイプ（変数） 渡された変数のタイプを返します。渡された変数がdictionaryの場合、辞書タイプを返します。

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

シニア番号	説明付きのメソッド
1	dict.clear（） 辞書のすべての要素を削除しdictのを
2	dict.copy（） 戻り値の辞書の浅いコピー辞書
3	dict.fromkeys（） seqのキーとvalueに設定された値を使用して新しい辞書を作成します。
4	dict.get（key、default = None） 以下のためのキー、キー、キーではない辞書であれば値またはデフォルト値を返します。
5	dict.has_key（key） 辞書dictのキーの場合はtrueを返し、それ以外の場合はfalseを返します。
6	dict.items（） dictの（キー、値）タプルペアのリストを返します
7	dict.keys（） 辞書辞書のキーのリストを返します
8	dict.setdefault（key、default = None） get（）に似ていますが、キーがまだdictにない場合は、dict [key] = defaultを設定します
9	dict.update（dict2） 辞書dict2のキーと値のペアをdictに追加します
10	dict.values（） 辞書dictの値のリストを返します

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

ティックとは何ですか？

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

人気があります time時間の操作や表現間の変換のための関数を提供するPythonで利用可能なモジュール。関数time.time（）は、1970年1月1日（エポック）の00:00: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つの数値のタプルとして処理します。

インデックス	フィールド	値
0	4桁の年	2008年
1	月	1から12
2	日	1から31
3	時間	0から23
4	分	0から59
5	2番目	0から61（60または61はうるう秒です）
6	曜日	0から6（0は月曜日）
7	曜日	1から366（ユリウス日）
8	夏時間	-1、0、1、-1は、ライブラリがDSTを決定することを意味します

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

インデックス	属性	値
0	tm_year	2008年
1	tm_mon	1から12
2	tm_mday	1から31
3	tm_hour	0から23
4	tm_min	0から59
5	tm_sec	0から61（60または61はうるう秒です）
6	tm_wday	0から6（0は月曜日）
7	tm_yday	1から366（ユリウス日）
8	tm_isdst	-1、0、1、-1は、ライブラリがDSTを決定することを意味します

現在の時刻を取得する

エポック浮動小数点値からの秒からの瞬間をタイムタプルに変換するには、浮動小数点値を、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で利用可能なモジュール。これが利用可能なすべての方法のリストです-

シニア番号	説明付きの関数
1	time.altzone ローカルDSTタイムゾーンのオフセット（UTCの西の秒数）（定義されている場合）。ローカルDSTタイムゾーンがUTCの東にある場合（英国を含む西ヨーロッパの場合など）、これはマイナスになります。日光がゼロ以外の場合にのみこれを使用してください。
2	time.asctime（[tupletime]） タイムタプルを受け入れ、「Tue Dec 1118：07：142008」などの読み取り可能な24文字の文字列を返します。
3	時計（ ） 現在の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がローカルルールによってインスタント秒に適用されるかどうかに応じて、t.tm_isdstは0または1です）。
7	time.mktime（tupletime） 現地時間のタイムタプルとして表されるインスタントを受け入れ、エポックからの秒数で表されるインスタントを含む浮動小数点値を返します。
8	time.sleep(secs) Suspends the calling thread for secs seconds.
9	time.strftime(fmt[,tupletime]) Accepts an instant expressed as a time-tuple in local time and returns a string representing the instant as specified by string fmt.
10	time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') Parses str according to format string fmt and returns the instant in time-tuple format.
11	time.time( ) Returns the current time instant, a floating-point number of seconds since the epoch.
12	time.tzset() Resets the time conversion rules used by the library routines. The environment variable TZ specifies how this is done.

Let us go through the functions briefly −

There are following two important attributes available with time module −

Sr.No.	Attribute with Description
1	time.timezone Attribute time.timezone is the offset in seconds of the local time zone (without DST) from UTC (>0 in the Americas; <=0 in most of Europe, Asia, Africa).
2	time.tzname Attribute time.tzname is a pair of locale-dependent strings, which are the names of the local time zone without and with DST, respectively.

The calendar Module

The calendar module supplies calendar-related functions, including functions to print a text calendar for a given month or year.

By default, calendar takes Monday as the first day of the week and Sunday as the last one. To change this, call calendar.setfirstweekday() function.

Here is a list of functions available with the calendar module −

Sr.No.	Function with Description
1	calendar.calendar(year,w=2,l=1,c=6) Returns a multiline string with a calendar for year year formatted into three columns separated by c spaces. w is the width in characters of each date; each line has length 21*w+18+2*c. l is the number of lines for each week.
2	calendar.firstweekday( ) Returns the current setting for the weekday that starts each week. By default, when calendar is first imported, this is 0, meaning Monday.
3	calendar.isleap(year) Returns True if year is a leap year; otherwise, False.
4	calendar.leapdays(y1,y2) Returns the total number of leap days in the years within range(y1,y2).
5	calendar.month(year,month,w=2,l=1) Returns a multiline string with a calendar for month month of year year, one line per week plus two header lines. w is the width in characters of each date; each line has length 7*w+6. l is the number of lines for each week.
6	calendar.monthcalendar(year,month) Returns a list of lists of ints. Each sublist denotes a week. Days outside month month of year year are set to 0; days within the month are set to their day-of-month, 1 and up.
7	calendar.monthrange(year,month) Returns two integers. The first one is the code of the weekday for the first day of the month month in year year; the second one is the number of days in the month. Weekday codes are 0 (Monday) to 6 (Sunday); month numbers are 1 to 12.
8	calendar.prcal(year,w=2,l=1,c=6) Like print calendar.calendar(year,w,l,c).
9	calendar.prmonth(year,month,w=2,l=1) Like print calendar.month(year,month,w,l).
10	calendar.setfirstweekday(weekday) Sets the first day of each week to weekday code weekday. Weekday codes are 0 (Monday) to 6 (Sunday).
11	calendar.timegm(tupletime) The inverse of time.gmtime: accepts a time instant in time-tuple form and returns the same instant as a floating-point number of seconds since the epoch.
12	calendar.weekday(year,month,day) Returns the weekday code for the given date. Weekday codes are 0 (Monday) to 6 (Sunday); month numbers are 1 (January) to 12 (December).

Other Modules & Functions

If you are interested, then here you would find a list of other important modules and functions to play with date & time in Python −

• The datetime Module

• The pytz Module

• The dateutil Module

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

ご存知のように、Pythonにはprint（）などの多くの組み込み関数がありますが、独自の関数を作成することもできます。これらの関数は、ユーザー定義関数と呼ばれます。

関数の定義

必要な機能を提供する関数を定義できます。Pythonで関数を定義するための簡単なルールは次のとおりです。

• ファンクションブロックはキーワードで始まります def その後に関数名と括弧（（））が続きます。

• 入力パラメーターまたは引数は、これらの括弧内に配置する必要があります。これらの括弧内にパラメーターを定義することもできます。

• 関数の最初のステートメントは、オプションのステートメント（関数のドキュメント文字列またはdocstring）にすることができます。

• すべての関数内のコードブロックはコロン（:)で始まり、インデントされます。

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

構文

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

可変長引数

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

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

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

匿名関数

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

• ラムダフォームは任意の数の引数を取ることができますが、式の形式で1つの値のみを返します。コマンドや複数の式を含めることはできません。

• ラムダには式が必要なため、無名関数を直接printに呼び出すことはできません

• Lambda関数には独自のローカル名前空間があり、パラメーターリスト内の変数とグローバル名前空間内の変数以外の変数にはアクセスできません。

• ラムダは関数の1行バージョンのように見えますが、パフォーマンス上の理由から呼び出し中に関数スタック割り当てを渡すことを目的とするCまたはC ++のインラインステートメントと同等ではありません。

構文

ラムダ関数の構文には、次のような1つのステートメントしか含まれていません。

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

以下は、ラムダ形式の関数がどのように機能するかを示す例です。

#!/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 [expression]は関数を終了し、オプションで式を呼び出し元に返します。引数のないreturnステートメントは、returnNoneと同じです。

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

#!/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つの基本的な変数のスコープがあります-

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

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

関数本体の内部で定義された変数にはローカルスコープがあり、外部で定義された変数にはグローバルスコープがあります。

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

#!/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コードで構成されるファイルです。モジュールは、関数、クラス、および変数を定義できます。モジュールには、実行可能なコードを含めることもできます。

例

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

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

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

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

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

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

...輸入声明

Pythonのfromステートメントを使用すると、特定の属性をモジュールから現在の名前空間にインポートできます。...インポートは、次の構文を持っています-

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

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

from fib import fibonacci

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

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

次のインポートステートメントを使用して、モジュールから現在の名前空間にすべての名前をインポートすることもできます。

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

名前空間とスコープ

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

Pythonステートメントは、ローカル名前空間とグローバル名前空間の変数にアクセスできます。ローカル変数とグローバル変数の名前が同じである場合、ローカル変数はグローバル変数をシャドウイングします。

各関数には、独自のローカル名前空間があります。クラスメソッドは、通常の関数と同じスコープ規則に従います。

Pythonは、変数がローカルかグローバルかについて、知識に基づいて推測します。関数内で値が割り当てられた変数はすべてローカルであると想定しています。

したがって、関数内のグローバル変数に値を割り当てるには、最初にグローバルステートメントを使用する必要があります。

声明グローバル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__はモジュールがロードされたファイル名です。

グローバル（）と地元の人々 （）関数

グローバル（）と地元の人々 （）関数は、それらが呼ばれている場所から場所に応じて、グローバルとローカルの名前空間内の名前を返すために使用することができます。

locals（）が関数内から呼び出されると、その関数からローカルにアクセスできるすべての名前が返されます。

globals（）が関数内から呼び出されると、その関数からグローバルにアクセスできるすべての名前が返されます。

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

リロード（）関数

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

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

reload(module_name)

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

reload(hello)

Pythonのパッケージ

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

ファイルを検討Pots.pyで利用可能な携帯電話のディレクトリを。このファイルには次のソースコードがあります-

#!/usr/bin/python

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

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

• 関数Isdn（）を持つPhone /Isdn.pyファイル

• 関数G3（）を持つPhone /G3.pyファイル

ここで、電話帳にもう1つのファイル__init__。pyを作成します-

• Phone/__init__.py

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

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

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

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

画面への印刷

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

#!/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
• input

raw_input機能

raw_inputは（[プロンプト]）関数は、文字列（末尾の改行を除去する）などの標準的な入力及び戻りから1行を読み出します。

#!/usr/bin/python

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

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

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

入力機能

入力（[プロンプト]）機能、入力が有効な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 オブジェクト。

オープン機能

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

構文

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

パラメータの詳細は次のとおりです-

• file_name − file_name引数は、アクセスするファイルの名前を含む文字列値です。

• access_mode− access_modeは、ファイルを開く必要のあるモード（読み取り、書き込み、追加など）を決定します。可能な値の完全なリストを以下の表に示します。これはオプションのパラメーターであり、デフォルトのファイルアクセスモードが読み取られます（r）。

• buffering−バッファリング値が0に設定されている場合、バッファリングは行われません。バッファリング値が1の場合、ファイルへのアクセス中に行バッファリングが実行されます。バッファリング値を1より大きい整数として指定すると、指定されたバッファサイズでバッファリングアクションが実行されます。負の場合、バッファサイズはシステムのデフォルト（デフォルトの動作）です。

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

シニア番号	モードと説明
1	r 読み取り専用のファイルを開きます。ファイルポインタはファイルの先頭に配置されます。これがデフォルトのモードです。
2	rb バイナリ形式でのみ読み取るためにファイルを開きます。ファイルポインタはファイルの先頭に配置されます。これがデフォルトのモードです。
3	r+ 読み取りと書き込みの両方のためにファイルを開きます。ファイルの先頭に配置されたファイルポインタ。
4	rb+ バイナリ形式で読み取りと書き込みの両方のファイルを開きます。ファイルの先頭に配置されたファイルポインタ。
5	w 書き込み専用のファイルを開きます。ファイルが存在する場合、ファイルを上書きします。ファイルが存在しない場合は、書き込み用の新しいファイルを作成します。
6	wb バイナリ形式でのみ書き込むためのファイルを開きます。ファイルが存在する場合、ファイルを上書きします。ファイルが存在しない場合は、書き込み用の新しいファイルを作成します。
7	w+ 書き込みと読み取りの両方のためにファイルを開きます。ファイルが存在する場合は、既存のファイルを上書きします。ファイルが存在しない場合は、読み取りおよび書き込み用の新しいファイルを作成します。
8	wb+ バイナリ形式での書き込みと読み取りの両方のためにファイルを開きます。ファイルが存在する場合は、既存のファイルを上書きします。ファイルが存在しない場合は、読み取りおよび書き込み用の新しいファイルを作成します。
9	a 追加するファイルを開きます。ファイルが存在する場合、ファイルポインタはファイルの最後にあります。つまり、ファイルは追加モードになっています。ファイルが存在しない場合は、書き込み用の新しいファイルが作成されます。
10	ab バイナリ形式で追加するファイルを開きます。ファイルが存在する場合、ファイルポインタはファイルの最後にあります。つまり、ファイルは追加モードになっています。ファイルが存在しない場合は、書き込み用の新しいファイルが作成されます。
11	a+ 追加と読み取りの両方のためにファイルを開きます。ファイルが存在する場合、ファイルポインタはファイルの最後にあります。ファイルは追加モードで開きます。ファイルが存在しない場合は、読み取りと書き込み用の新しいファイルが作成されます。
12	ab+ 追加と読み取りの両方のためにバイナリ形式でファイルを開きます。ファイルが存在する場合、ファイルポインタはファイルの最後にあります。ファイルは追加モードで開きます。ファイルが存在しない場合は、読み取りと書き込み用の新しいファイルが作成されます。

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

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

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

シニア番号	属性と説明
1	file.closed ファイルが閉じている場合はtrueを返し、それ以外の場合はfalseを返します。
2	file.mode ファイルを開いたときのアクセスモードを返します。
3	file.name ファイルの名前を返します。
4	file.softspace printでスペースが明示的に必要な場合は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（）メソッドは、書き込まれていない情報をフラッシュしてファイルオブジェクトを閉じます。その後、書き込みを行うことはできなくなります。

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

ファイルの読み取りと書き込み

ファイルオブジェクトは、私たちの生活を容易にするために、アクセス・メソッドのセットを提供します。私たちは、使用方法を見ることになるのread（）と書き込み（）読み取りと書き込みのファイルする方法を。

書き込み（）メソッド

書き込み（）メソッドは、開いているファイルに任意の文字列を書き込みます。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!!

読み取り（）メソッド

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

構文

fileObject.read([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（）メソッドを使用すると、ファイル内の現在位置を伝えます。つまり、次の読み取りまたは書き込みは、ファイルの先頭からそのバイト数で発生します。

シーク（オフセット[、から]）メソッドは、現在のファイル位置を変更します。オフセット引数は、移動すべきバイト数を示します。以下からの引数は、バイトが移動される場所からの基準位置を特定します。

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（）メソッド

名前の変更（）メソッドは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（）メソッドを使用して、削除するファイルの名前を引数として指定することにより、ファイルを削除できます。

構文

os.remove(file_name)

例

以下は、既存のファイルを削除する例ですtest2.txtという名前を-

#!/usr/bin/python
import os

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

Pythonのディレクトリ

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

MKDIR（）メソッド

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

構文

os.mkdir("newdir")

例

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

#!/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"  )

ファイルとディレクトリに関連するメソッド

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

• ファイルオブジェクトメソッド：ファイルオブジェクトは、ファイルを操作するための関数を提供します。

• OSオブジェクトメソッド：これは、ディレクトリだけでなくファイルを処理するためのメソッドを提供します。

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

• Exception Handling−これはこのチュートリアルでカバーされます。Pythonで使用できる標準の例外のリストは次のとおりです。標準の例外。

• Assertions−これはPythonチュートリアルのアサーションでカバーされます。

標準例外のリスト-

シニア番号	例外の名前と説明
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ステートメント）。式がテストされ、結果がfalseになると、例外が発生します。

アサーションは、バージョン1.5で導入されたPythonの最新キーワードであるassertステートメントによって実行されます。

プログラマーは、有効な入力をチェックするために関数の開始時にアサーションを配置し、有効な出力をチェックするために関数呼び出しの後にアサーションを配置することがよくあります。

アサートステートメント

アサートステートメントに遭遇すると、Pythonは付随する式を評価します。これはうまくいけばtrueです。式がfalseの場合、PythonはAssertionError例外を発生させます。

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

assert Expression[, Arguments]

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

例

これは、温度をケルビン度から華氏度に変換する関数です。ケルビンが0度になると低温になるため、負の温度が発生すると関数は無効になります。

#!/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スクリプトで例外が発生した場合は、すぐに例外を処理する必要があります。そうしないと、終了して終了します。

例外の処理

例外を発生させる可能性のある疑わしいコードがある場合は、疑わしいコードをに配置することでプログラムを防御できます。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句を指定することもできます。

• 例外句の後に、else句を含めることができます。elseブロックのコードは、try：ブロックのコードで例外が発生しない場合に実行されます。

• 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ステートメントを使用することもできます-

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ステートメントを使用して複数の例外を処理することもできます。

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.

トライファイナル条項

あなたは使用することができます finally: と一緒にブロック try:ブロック。finalブロックは、tryブロックで例外が発生したかどうかに関係なく、実行する必要のあるコードを配置する場所です。try-finallyステートメントの構文は次のとおりです-

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

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

例

#!/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ブロックに渡されます。finishブロック内のすべてのステートメントが実行された後、例外が再度発生し、try-exceptステートメントの次の上位層に存在する場合はexceptステートメントで処理されます。

例外の引数

例外には引数を含めることができます。これは、問題に関する追加情報を提供する値です。引数の内容は例外によって異なります。次のように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

Note:例外をキャッチするには、「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のオブジェクト指向プログラミングサポートの使用に関するエキスパートになるのに役立ちます。

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

ただし、ここでは、オブジェクト指向プログラミング（OOP）を簡単に紹介します。

OOP用語の概要

• Class−クラスの任意のオブジェクトを特徴付ける属性のセットを定義するオブジェクトのユーザー定義のプロトタイプ。属性はデータメンバー（クラス変数とインスタンス変数）とメソッドであり、ドット表記を介してアクセスされます。

• Class variable−クラスのすべてのインスタンスで共有される変数。クラス変数は、クラス内で定義されますが、クラスのメソッドの外部で定義されます。クラス変数は、インスタンス変数ほど頻繁には使用されません。

• Data member −クラスとそのオブジェクトに関連付けられたデータを保持するクラス変数またはインスタンス変数。

• Function overloading−特定の機能への複数の動作の割り当て。実行される操作は、関連するオブジェクトまたは引数のタイプによって異なります。

• Instance variable −メソッド内で定義され、クラスの現在のインスタンスにのみ属する変数。

• Inheritance −クラスの特性をそのクラスから派生した他のクラスに転送する。

• Instance−特定のクラスの個々のオブジェクト。たとえば、クラスCircleに属するオブジェクトobjは、クラスCircleのインスタンスです。

• Instantiation −クラスのインスタンスの作成。

• Method −クラス定義で定義されている特別な種類の関数。

• Object−クラスによって定義されたデータ構造の一意のインスタンス。オブジェクトは、データメンバー（クラス変数とインスタンス変数）とメソッドの両方で構成されます。

• Operator overloading −特定の演算子への複数の関数の割り当て。

クラスの作成

クラスステートメントは、新しいクラス定義を作成します。クラスの名前はすぐにキーワード以下のクラスは次のようにコロン-

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は、自己引数をリストに追加します。メソッドを呼び出すときにそれを含める必要はありません。

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

クラスのインスタンスを作成するには、クラス名を使用してクラスを呼び出し、その__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 <40>
b = a       # Increase ref. count  of <40> 
c = [b]     # Increase ref. count  of <40> 

del a       # Decrease ref. count  of <40>
b = 100     # Decrease ref. count  of <40> 
c[0] = -1   # Decrease ref. count  of <40>

通常、ガベージコレクターが孤立したインスタンスを破棄し、そのスペースを再利用することに気付くことはありません。ただし、クラスは、インスタンスが破棄されようとしているときに呼び出される、デストラクタと呼ばれる特別なメソッド__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

Note−理想的には、クラスを別のファイルで定義してから、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(sub, sup) 指定されたサブクラスの場合、ブール関数はtrueを返します sub 確かにスーパークラスのサブクラスです sup。

• ザ・ isinstance(obj, Class)objがクラスClassのインスタンスであるか、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

ベースオーバーロードメソッド

次の表に、独自のクラスでオーバーライドできるいくつかの一般的な機能を示します。

シニア番号	メソッド、説明、サンプルコール
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クラスを作成したとすると、plus演算子を使用してそれらを追加するとどうなりますか？おそらくPythonはあなたに怒鳴ります。

ただし、クラスで__add__メソッドを定義してベクトルの加算を実行すると、plus演算子は期待どおりに動作します。

例

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

正規表現は、あなたが一致するかのパターンで開催された、特殊な構文を使用して他の文字列または文字列のセットを、見つけることができます文字の特別なシーケンスです。正規表現はUNIXの世界で広く使用されています。

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

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

マッチ機能

この関数は、オプションのフラグを使用してREパターンを文字列に一致させようとします。

この関数の構文は次のとおりです-

re.match(pattern, string, flags=0)

パラメータの説明は次のとおりです-

シニア番号	パラメータと説明
1	pattern これは、照合される正規表現です。
2	string これは文字列であり、文字列の先頭のパターンに一致するように検索されます。
3	flags ビットごとのOR（|）を使用して、さまざまなフラグを指定できます。これらは修飾子であり、以下の表にリストされています。

re.match関数が返すのAmatch 成功の反対、 None失敗したとき。group（num）またはgroups（）関数を使用しますmatch 一致する式を取得するオブジェクト。

シニア番号	一致オブジェクトのメソッドと説明
1	group(num=0) このメソッドは、一致全体（または特定のサブグループ番号）を返します
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

検索機能

この関数は、オプションのフラグを使用して、文字列内で最初に出現するREパターンを検索します。

この関数の構文は次のとおりです-

re.search(pattern, string, flags=0)

パラメータの説明は次のとおりです-

シニア番号	パラメータと説明
1	pattern これは、照合される正規表現です。
2	string これは文字列であり、文字列内の任意の場所のパターンに一致するように検索されます。
3	flags ビットごとのOR（|）を使用して、さまざまなフラグを指定できます。これらは修飾子であり、以下の表にリストされています。

re.search関数が返すのAmatch 成功の反対、 none失敗したとき。group（num）またはgroups（）関数を使用しますmatch 一致する式を取得するオブジェクト。

シニア番号	一致オブジェクトのメソッドと説明
1	group(num=0) このメソッドは、一致全体（または特定のサブグループ番号）を返します
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つの異なるプリミティブ操作を提供します。 match 文字列の先頭でのみ一致をチェックしますが、 search 文字列内の任意の場所で一致するかどうかをチェックします（これはPerlがデフォルトで行うことです）。

例

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

検索と置換

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

構文

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

このメソッドは、文字列内のREパターンのすべてのオカレンスを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

正規表現修飾子：オプションフラグ

正規表現リテラルには、マッチングのさまざまな側面を制御するためのオプションの修飾子が含まれる場合があります。修飾子はオプションのフラグとして指定されます。前に示したように、排他的論理和（|）を使用して複数の修飾子を指定でき、これらのいずれかで表すことができます。

シニア番号	修飾子と説明
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で使用できる正規表現の構文を示します。

シニア番号	パターンと説明
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	\10 すでに一致している場合は、n番目のグループ化された部分式に一致します。それ以外の場合は、文字コードの8進表現を指します。

正規表現の例

リテラル文字

シニア番号	例と説明
1	python 「python」に一致します。

キャラクタークラス

シニア番号	例と説明
1	[Pp]ython 「Python」または「python」に一致
2	rub[ye] 「ruby」または「rube」に一致
3	[aeiou] 任意の1つの小文字の母音に一致します
4	[0-9] 任意の数字に一致します。[0123456789]と同じ
5	[a-z] 任意の小文字のASCII文字に一致します
6	[A-Z] 任意の大文字のASCII文字に一致します
7	[a-zA-Z0-9] 上記のいずれかに一致する
8	[^aeiou] 小文字の母音以外に一致する
9	[^0-9] 数字以外のものと一致する

特殊文字クラス

シニア番号	例と説明
1	. 改行以外の任意の文字に一致します
2	\d 数字に一致：[0-9]
3	\D 数字以外に一致する：[^ 0-9]
4	\s 空白文字に一致します：[\ t \ r \ n \ f]
5	\S 非空白に一致：[^ \ t \ r \ n \ f]
6	\w 1つの単語の文字に一致します：[A-Za-z0-9_]
7	\W 単語以外の文字に一致する：[^ A-Za-z0-9_]

繰り返しの場合

シニア番号	例と説明
1	ruby? 「rub」または「ruby」に一致：yはオプションです
2	ruby* 「摩擦」に0以上のysを加えたものに一致する
3	ruby+ 「摩擦」と1つ以上のysを一致させる
4	\d{3} 正確に3桁一致
5	\d{3,} 3桁以上一致する
6	\d{3,5} 3、4、または5桁に一致

貪欲でない繰り返し

これは最小の繰り返し数に一致します-

シニア番号	例と説明
1	<.*> 貪欲な繰り返し：「<python> perl>」に一致
2	<.*?> 貪欲でない：「<python> perl>」の「<python>」に一致します

括弧でグループ化

シニア番号	例と説明
1	\D\d+ グループなし：+繰り返し\ d
2	(\D\d)+ グループ化：+ \ D \ dペアを繰り返す
3	([Pp]ython(, )?)+ 「Python」、「Python、python、python」などに一致します。

後方参照

これは、以前に一致したグループと再び一致します-

シニア番号	例と説明
1	([Pp])ython&\1ails python＆pailsまたはPython＆Pailsに一致します
2	(['"])[^\1]*\1 一重引用符または二重引用符で囲まれた文字列。\ 1は、最初のグループが一致したものに一致します。\ 2は、2番目のグループが一致したものに一致します。

代替案

シニア番号	例と説明
1	python|perl 「python」または「perl」に一致
2	rub(y|le)) 「ルビー」または「ルーブル」に一致
3	Python(!+|\?) 「Python」の後に1つ以上！または1つ？

アンカー

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

シニア番号	例と説明
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」と一致します。

括弧付きの特別な構文

シニア番号	例と説明
1	R(?#comment) 「R」に一致します。残りはすべてコメントです
2	R(?i)uby 「uby」との照合では大文字と小文字を区別しない
3	R(?i:uby) 同上
4	rub(?:y|le)) \ 1後方参照を作成せずにグループ化のみ

Common Gateway Interface（CGI）は、Webサーバーとカスタムスクリプトの間で情報を交換する方法を定義する一連の標準です。CGI仕様は、現在NCSAによって維持されています。

CGIとは何ですか？

• Common Gateway Interface（CGI）は、外部ゲートウェイプログラムがHTTPサーバーなどの情報サーバーとインターフェイスするための標準です。

• 現在のバージョンはCGI / 1.1であり、CGI /1.2は進行中です。

Webブラウジング

CGIの概念を理解するために、ハイパーリンクをクリックして特定のWebページまたはURLを参照するとどうなるかを見てみましょう。

• ブラウザはHTTPWebサーバーに接続し、URL、つまりファイル名を要求します。

• WebサーバーはURLを解析し、ファイル名を探します。そのファイルが見つかった場合はブラウザに送り返します。それ以外の場合は、間違ったファイルをリクエストしたことを示すエラーメッセージを送信します。

• WebブラウザはWebサーバーから応答を受け取り、受信したファイルまたはエラーメッセージのいずれかを表示します。

ただし、特定のディレクトリ内のファイルが要求されたときにそのファイルが返送されないようにHTTPサーバーを設定することは可能です。代わりに、プログラムとして実行され、そのプログラムが出力するものはすべて、ブラウザに表示するために送り返されます。この機能はCommonGateway InterfaceまたはCGIと呼ばれ、プログラムはCGIスクリプトと呼ばれます。これらのCGIプログラムには、Pythonスクリプト、PERLスクリプト、シェルスクリプト、CまたはC ++プログラムなどがあります。

CGIアーキテクチャ図

Webサーバーのサポートと構成

CGIプログラミングを続行する前に、WebサーバーがCGIをサポートし、CGIプログラムを処理するように構成されていることを確認してください。HTTPサーバーによって実行されるすべてのCGIプログラムは、事前設定されたディレクトリに保存されます。このディレクトリはCGIディレクトリと呼ばれ、慣例により/ var / www / cgi-binという名前が付けられています。慣例により、CGIファイルの拡張子はとしてです。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プログラム

これは、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ファイル（画面）に書き込みます。印刷される最初の行である利用可能な1つの重要で追加の機能がありますContent-type:text/html\r\n\r\n。この行はブラウザに返送され、ブラウザ画面に表示されるコンテンツタイプを指定します。

これで、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ヘッダーは他にもいくつかあります。

シニア番号	ヘッダーと説明
1	Content-type: 返されるファイルの形式を定義するMIME文字列。例はContent-type：text / htmlです
2	Expires: Date 情報が無効になる日付。これは、ページを更新する必要がある時期を決定するためにブラウザによって使用されます。有効な日付文字列は、1998年1月1日12：00：00GMTの形式です。
3	Location: URL 要求されたURLの代わりに返されるURL。このフィールドを使用して、リクエストを任意のファイルにリダイレクトできます。
4	Last-modified: Date リソースが最後に変更された日付。
5	Content-length: N 返されるデータの長さ（バイト単位）。ブラウザはこの値を使用して、ファイルの推定ダウンロード時間を報告します。
6	Set-Cookie: String 文字列を介して渡されるCookieを設定します

CGI環境変数

すべてのCGIプログラムは、次の環境変数にアクセスできます。これらの変数は、CGIプログラムを作成する際に重要な役割を果たします。

シニア番号	変数名と説明
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プログラムです。結果は表示するには、このリンクをクリックして環境を手に入れよう

#!/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プログラムに情報を渡す必要がある場合、多くの状況に遭遇したに違いありません。ほとんどの場合、ブラウザは2つの方法を使用し、2つはこの情報をWebサーバーに渡します。これらのメソッドは、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と連結するだけで情報を渡すか、HTML <FORM>タグを使用してGETメソッドを使用して情報を渡すことができます。

単純なURLの例：Getメソッド

これは、GETメソッドを使用してhello_get.pyプログラムに2つの値を渡す単純なURLです。

/cgi-bin/hello_get.py?first_name=ZARA&last_name=ALI

以下であり hello_get.pyWebブラウザからの入力を処理するスクリプト。使用します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>"

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

こんにちはZARAALI

単純なFORMの例：GETメソッド

この例では、HTMLFORMと送信ボタンを使用して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>"

HTMLFORMと送信ボタンを使用して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を取得できるようになります。取得されると、サーバーは何が保存されたかを認識/記憶します。

Cookieは、5つの可変長フィールドのプレーンテキストデータレコードです-

• Expires−Cookieの有効期限が切れる日付。これが空白の場合、訪問者がブラウザを終了するとCookieは期限切れになります。

• Domain −サイトのドメイン名。

• Path−Cookieを設定するディレクトリまたはWebページへのパス。任意のディレクトリまたはページからCookieを取得する場合は、これを空白にすることができます。

• Secure−このフィールドに「セキュア」という単語が含まれている場合、Cookieはセキュアサーバーでのみ取得できます。このフィールドが空白の場合、そのような制限はありません。

• Name=Value − Cookieは、キーと値のペアの形式で設定および取得されます。

クッキーの設定

ブラウザにCookieを送信するのは非常に簡単です。これらのCookieは、HTTPヘッダーとともにContent-typeフィールドに送信されます。ユーザー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.tutorialspoint.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 Cookieを設定するためのHTTPヘッダー。

Expires、Domain、PathなどのCookie属性を設定することはオプションです。マジックラインを送信する前にCookieが設定されていることは注目に値します"Content-type:text/html\r\n\r\n。

クッキーの取得

設定されたすべての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()

このチュートリアルを楽しんでいただけたでしょうか。はいの場合は、フィードバックをお送りください。お問い合わせ

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

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

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• Oracle
• Sybase

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

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

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

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

MySQLdbとは何ですか？

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

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

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

データベース接続

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

• データベースTESTDBを作成しました。

• TESTDBにテーブルEMPLOYEEを作成しました。

• このテーブルには、フィールドFIRST_NAME、LAST_NAME、AGE、SEX、およびINCOMEがあります。

• TESTDBにアクセスするためのユーザーID「testuser」とパスワード「test123」が設定されています。

• PythonモジュールMySQLdbがマシンに正しくインストールされています。

• MySQLの基本を理解するためにMySQLチュートリアルを完了しました。

例

以下は、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 それ以外の場合は、さらに使用します dbNoneに設定されています。次、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操作

任意のデータベースでのREAD操作は、データベースからいくつかの有用な情報をフェッチすることを意味します。

データベース接続が確立されると、このデータベースにクエリを実行する準備が整います。どちらでも使用できますfetchone() 単一のレコードをフェッチする方法または fetchall() データベーステーブルから複数の値をfetechする方法。

• 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'。ここでは、すべての男性のAGEを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操作

データベースから一部のレコードを削除する場合は、DELETE操作が必要です。以下は、AGEが20を超える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 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 −トランザクションが完了するか、まったく何も起こりません。

• Consistency −トランザクションは一貫性のある状態で開始し、システムを一貫性のある状態のままにする必要があります。

• Isolation −トランザクションの中間結果は、現在のトランザクションの外部には表示されません。

• Durability −トランザクションがコミットされると、システム障害が発生した後でも、影響は持続します。

Python DB API 2.0には、トランザクションをコミットまたはロールバックするための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操作

コミットは、変更を確定するためにデータベースに緑色の信号を与える操作であり、この操作の後、変更を元に戻すことはできません。

これが呼び出す簡単な例です commit 方法。

db.commit()

ロールバック操作

1つ以上の変更に満足できず、それらの変更を完全に元に戻したい場合は、次を使用します。 rollback() 方法。

これが呼び出す簡単な例です rollback() 方法。

db.rollback()

データベースの切断

データベース接続を切断するには、close（）メソッドを使用します。

db.close()

ユーザーがclose（）メソッドを使用してデータベースへの接続を閉じた場合、未処理のトランザクションはすべてDBによってロールバックされます。ただし、DBの下位レベルの実装の詳細に依存するのではなく、commitまたはrollbackを明示的に呼び出す方がアプリケーションの方が適しています。

エラーの処理

エラーの原因はたくさんあります。いくつかの例は、実行されたSQLステートメントの構文エラー、接続の失敗、またはすでにキャンセルまたは終了したステートメントハンドルのフェッチメソッドの呼び出しです。

DB APIは、各データベースモジュールに存在しなければならないいくつかのエラーを定義します。次の表に、これらの例外を示します。

シニア番号	例外と説明
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は、ネットワークサービスへの2つのレベルのアクセスを提供します。低レベルでは、基盤となるオペレーティングシステムの基本的なソケットサポートにアクセスできます。これにより、コネクション型プロトコルとコネクションレス型プロトコルの両方のクライアントとサーバーを実装できます。

Pythonには、FTP、HTTPなどの特定のアプリケーションレベルのネットワークプロトコルへの高レベルのアクセスを提供するライブラリもあります。

この章では、ネットワーキングの最も有名な概念であるソケットプログラミングについて理解します。

ソケットとは何ですか？

ソケットは、双方向通信チャネルのエンドポイントです。ソケットは、プロセス内、同じマシン上のプロセス間、または異なる大陸のプロセス間で通信できます。

ソケットは、Unixドメインソケット、TCP、UDPなどのさまざまなチャネルタイプで実装できます。ソケットライブラリは、共通のトランスポートだけでなく、残りの部分を処理するための汎用インタフェースを処理するための特定のクラスを提供します。

ソケットには独自の語彙があります-

シニア番号	用語と説明
1	Domain トランスポートメカニズムとして使用されるプロトコルのファミリー。これらの値は、AF_INET、PF_INET、PF_UNIX、PF_X25などの定数です。
2	type 2つのエンドポイント間の通信のタイプ。通常、コネクション型プロトコルの場合はSOCK_STREAM、コネクションレス型プロトコルの場合はSOCK_DGRAMです。
3	protocol 通常はゼロです。これは、ドメインおよびタイプ内のプロトコルのバリアントを識別するために使用できます。
4	hostname ネットワークインターフェースの識別子- 文字列。ホスト名、ドット付きクワッドアドレス、またはコロン（場合によってはドット）表記のIPV6アドレスにすることができます。 INADDR_BROADCASTアドレスを指定する文字列「<broadcast>」。 INADDR_ANYを指定する長さゼロの文字列、または ホストバイト順のバイナリアドレスとして解釈される整数。
5	port 各サーバーは、1つ以上のポートで呼び出すクライアントをリッスンします。ポートは、Fixnumポート番号、ポート番号を含む文字列、またはサービスの名前です。

ソケットモジュール

ソケットを作成するには、ソケットモジュールで使用可能なsocket.socket（）関数を使用する必要があります。この関数の一般的な構文は-です。

s = socket.socket (socket_family, socket_type, protocol=0)

パラメータの説明は次のとおりです-

• socket_family −これは、前に説明したように、AF_UNIXまたはAF_INETのいずれかです。

• socket_type −これはSOCK_STREAMまたはSOCK_DGRAMのいずれかです。

• protocol −これは通常省略され、デフォルトは0です。

ソケットオブジェクトを取得したら、必要な関数を使用してクライアントまたはサーバープログラムを作成できます。以下は必要な機能のリストです-

サーバーソケットメソッド

シニア番号	方法と説明
1	s.bind() このメソッドは、アドレス（ホスト名、ポート番号のペア）をソケットにバインドします。
2	s.listen() このメソッドは、TCPリスナーをセットアップして開始します。
3	s.accept() これは、TCPクライアント接続を受動的に受け入れ、接続が到着するまで待機します（ブロッキング）。

クライアントソケットメソッド

シニア番号	方法と説明
1	s.connect() このメソッドは、TCPサーバー接続をアクティブに開始します。

一般的なソケットメソッド

シニア番号	方法と説明
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)指定されたホスト上のサービスのポートを指定する関数。

次に、返されたオブジェクトのacceptメソッドを呼び出します。このメソッドは、クライアントが指定したポートに接続するまで待機してから、そのクライアントへの接続を表す接続オブジェクトを返します。

#!/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.connect(hosname, port )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ネットワーク/インターネットプログラミングのいくつかの重要なモジュールのリスト。

プロトコル	共通機能	ポート番号	Pythonモジュール
HTTP	ウェブページ	80	httplib、urllib、xmlrpclib
NNTP	Usenetニュース	119	nntplib
FTP	ファイル転送	20	ftplib、urllib
SMTP	メールの送信	25	smtplib
POP3	メールを取得する	110	poplib
IMAP4	メールを取得する	143	imaplib
Telnet	コマンドライン	23	telnetlib
Gopher	ドキュメントの転送	70	gopherlib、urllib

FTP、SMTP、POP、およびIMAPプロトコルで動作するには、上記のすべてのライブラリを確認してください。

さらなる読み物

これは、ソケットプログラミングのクイックスタートでした。それは広大な主題です。詳細については、次のリンクを参照することをお勧めします-

• Unixソケットプログラミング。

• Pythonソケットライブラリとモジュール。

Simple Mail Transfer Protocol（SMTP）は、電子メールの送信とメールサーバー間の電子メールのルーティングを処理するプロトコルです。

Pythonは提供します smtplib モジュール。SMTPまたはESMTPリスナーデーモンを使用して任意のインターネットマシンにメールを送信するために使用できるSMTPクライアントセッションオブジェクトを定義します。

これは、後で電子メールを送信するために使用できる1つのSMTPオブジェクトを作成するための簡単な構文です。

import smtplib

smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

パラメータの詳細は次のとおりです-

• host−これはSMTPサーバーを実行しているホストです。ホストのIPアドレスまたはtutorialspoint.comのようなドメイン名を指定できます。これはオプションの引数です。

• port−ホスト引数を指定する場合は、SMTPサーバーがリッスンしているポートを指定する必要があります。通常、このポートは25になります。

• local_hostname− SMTPサーバーがローカルマシンで実行されている場合は、このオプションの時点でlocalhostのみを指定できます。

SMTPオブジェクトには、というインスタンスメソッドがあります sendmail、これは通常、メッセージをメールで送信する作業を行うために使用されます。それは3つのパラメータを取ります-

• 送信者-送信者のアドレスを持つ文字列。

• 受信機-文字列のリスト、各受信者の1。

• メッセージ-様々な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! Mailなど）を使用している場合を除き、電子メールプロバイダーは、次のように、提供できる送信メールサーバーの詳細を提供している必要があります。

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

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

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

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

例

以下は、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"

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

• プロセス内の複数のスレッドは、メインスレッドと同じデータスペースを共有するため、別々のプロセスである場合よりも簡単に情報を共有したり、相互に通信したりできます。

• スレッドは軽量プロセスと呼ばれることもあり、メモリのオーバーヘッドをあまり必要としません。それらはプロセスよりも安価です。

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

• プリエンプト（中断）できます

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

新しいスレッドの開始

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

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

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

The method call returns immediately and the child thread starts and calls function with the passed list of args. When function returns, the thread terminates.

Here, args is a tuple of arguments; use an empty tuple to call function without passing any arguments. kwargs is an optional dictionary of keyword arguments.

Example

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

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

スレッディング・モジュール

Python 2.4に含まれている新しいスレッドモジュールは、前のセクションで説明したスレッドモジュールよりもはるかに強力で高レベルのスレッドサポートを提供します。

スレッドモジュールは、すべてのメソッド公開さスレッドモジュールを、いくつかの追加の方法を提供します-

• threading.activeCount() −アクティブなスレッドオブジェクトの数を返します。

• threading.currentThread() −呼び出し元のスレッドコントロール内のスレッドオブジェクトの数を返します。

• threading.enumerate() −現在アクティブなすべてのスレッドオブジェクトのリストを返します。

メソッドに加えて、スレッドモジュールにはスレッドを実装するThreadクラスがあります。Threadクラスが提供するメソッドは次のとおりです。

• run() − run（）メソッドは、スレッドのエントリポイントです。

• start() − start（）メソッドは、runメソッドを呼び出してスレッドを開始します。

• join([time]) − join（）は、スレッドが終了するのを待ちます。

• isAlive() − isAlive（）メソッドは、スレッドがまだ実行中であるかどうかをチェックします。

• getName() − getName（）メソッドはスレッドの名前を返します。

• setName() − setName（）メソッドは、スレッドの名前を設定します。

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

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

• Threadクラスの新しいサブクラスを定義します。

• __init __（self [、args]）メソッドをオーバーライドして、引数を追加します。

• 次に、run（self [、args]）メソッドをオーバーライドして、開始時にスレッドが実行する必要があることを実装します。

新しいThreadサブクラスを作成したら、そのインスタンスを作成し、start（）を呼び出して新しいスレッドを開始します。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, self.counter, 5)
      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）メソッドは、スレッドを強制的に同期的に実行するために使用されます。オプションのブロッキングパラメータを使用すると、スレッドがロックの取得を待機するかどうかを制御できます。

ブロッキングが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

マルチスレッド優先キュー

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

• get() − get（）は、キューからアイテムを削除して返します。

• 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

XMLは、オペレーティングシステムや開発言語に関係なく、プログラマーが他のアプリケーションで読み取ることができるアプリケーションを開発できるようにする、移植可能なオープンソース言語です。

XMLとは何ですか？

Extensible Markup Language（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 −これは、ファイル全体がメモリに読み込まれ、階層（ツリーベース）形式で格納されてXMLドキュメントのすべての機能を表すWorld WideWebコンソーシアムの推奨事項です。

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>

SAXAPIを使用したXMLの解析

SAXは、イベント駆動型XML解析の標準インターフェースです。SAXを使用してXMLを解析するには、通常、xml.sax.ContentHandlerをサブクラス化して独自のContentHandlerを作成する必要があります。

あなたのContentHandlerは、特定のタグを処理し、XMLのあなたの味（複数可）の属性。ContentHandlerオブジェクトは、さまざまな解析イベントを処理するためのメソッドを提供します。所有するパーサーは、XMLファイルを解析するときにContentHandlerメソッドを呼び出します。

メソッドstartDocumentおよびendDocumentは、XMLファイルの最初と最後で呼び出されます。メソッドcharacters（text）は、パラメーターtextを介してXMLファイルの文字データを渡します。

ContentHandlerは、各要素の開始時と終了時に呼び出されます。パーサーが名前空間モードでない場合、メソッドstartElement（tag、attributes）およびendElement（tag）が呼び出されます。それ以外の場合は、対応するメソッドstartElementNSおよびendElementNSが呼び出されます。ここで、tagは要素タグであり、attributesはAttributesオブジェクトです。

先に進む前に理解しておくべき他の重要な方法は次のとおりです-

make_parser方法

次のメソッドは、新しいパーサーオブジェクトを作成し、それを返します。作成されるパーサーオブジェクトは、システムが最初に検出するパーサータイプになります。

xml.sax.make_parser( [parser_list] )

パラメータの詳細は次のとおりです-

• parser_list −使用するパーサーのリストで構成されるオプションの引数。すべてmake_parserメソッドを実装する必要があります。

解析方法

次のメソッドは、SAXパーサーを作成し、それを使用してドキュメントを解析します。

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

パラメータの詳細は次のとおりです-

• xmlfile −これは読み取り元のXMLファイルの名前です。

• contenthandler −これはContentHandlerオブジェクトである必要があります。

• errorhandler −指定する場合、errorhandlerはSAXErrorHandlerオブジェクトである必要があります。

parseString方法

SAXパーサーを作成し、指定されたパーサーを解析する方法がもう1つあります。 XML string。

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

パラメータの詳細は次のとおりです-

• xmlstring −これは、読み取るXML文字列の名前です。

• contenthandler −これはContentHandlerオブジェクトである必要があります。

• errorhandler −指定する場合、errorhandlerはSAXErrorHandlerオブジェクトである必要があります。

例

#!/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ドキュメントの詳細については、標準のPython SAXAPIを参照してください。

DOMAPIを使用したXMLの解析

ドキュメントオブジェクトモデル（「DOM」）は、XMLドキュメントにアクセスして変更するためのWorld Wide Webコンソーシアム（W3C）のクロスランゲージAPIです。

DOMは、ランダムアクセスアプリケーションに非常に役立ちます。SAXでは、一度に1ビットのドキュメントしか表示できません。ある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ドキュメントの詳細については、標準のPython DOMAPIを参照してください。

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

• Tkinter− Tkinterは、Pythonに同梱されているTkGUIツールキットへのPythonインターフェースです。この章では、このオプションについて説明します。

• wxPython −これはwxWindows用のオープンソースのPythonインターフェースです http://wxpython.org。

• JPython − JPythonはJava用のPythonポートであり、Pythonスクリプトがローカルマシン上のJavaクラスライブラリにシームレスにアクセスできるようにします。 http://www.jython.org。

利用可能な他の多くのインターフェースがあり、それらはネット上で見つけることができます。

Tkinterプログラミング

TkinterはPythonの標準GUIライブラリです。PythonをTkinterと組み合わせると、GUIアプリケーションをすばやく簡単に作成できます。Tkinterは、TkGUIツールキットへの強力なオブジェクト指向インターフェースを提供します。

Tkinterを使用してGUIアプリケーションを作成するのは簡単な作業です。あなたがする必要があるのは次のステップを実行することです-

• Tkinterモジュールをインポートします。

• GUIアプリケーションのメインウィンドウを作成します。

• 上記のウィジェットを1つ以上GUIアプリケーションに追加します。

• メインイベントループに入り、ユーザーによってトリガーされた各イベントに対してアクションを実行します。

例

#!/usr/bin/python

import Tkinter
top = Tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()

これにより、次のウィンドウが作成されます-

Tkinterウィジェット

Tkinterは、GUIアプリケーションで使用されるボタン、ラベル、テキストボックスなどのさまざまなコントロールを提供します。これらのコントロールは一般にウィジェットと呼ばれます。

Tkinterには現在15種類のウィジェットがあります。これらのウィジェットと簡単な説明を次の表に示します-

シニア番号	オペレーターと説明
1	ボタン ボタンウィジェットは、アプリケーションのボタンを表示するために使用されます。
2	キャンバス Canvasウィジェットは、アプリケーションで線、楕円、多角形、長方形などの形状を描画するために使用されます。
3	チェックボタン チェックボタンウィジェットは、チェックボックスとしていくつかのオプションを表示するために使用されます。ユーザーは一度に複数のオプションを選択できます。
4	エントリ エントリウィジェットは、ユーザーからの値を受け入れるための1行のテキストフィールドを表示するために使用されます。
5	フレーム フレームウィジェットは、他のウィジェットを整理するためのコンテナウィジェットとして使用されます。
6	ラベル ラベルウィジェットは、他のウィジェットに1行のキャプションを提供するために使用されます。画像を含めることもできます。
7	リストボックス リストボックスウィジェットは、オプションのリストをユーザーに提供するために使用されます。
8	メニューボタン Menubuttonウィジェットは、アプリケーションのメニューを表示するために使用されます。
9	メニュー メニューウィジェットは、ユーザーにさまざまなコマンドを提供するために使用されます。これらのコマンドはMenubutton内に含まれています。
10	メッセージ メッセージウィジェットは、ユーザーからの値を受け入れるための複数行のテキストフィールドを表示するために使用されます。
11	ラジオボタン ラジオボタンウィジェットは、ラジオボタンとしていくつかのオプションを表示するために使用されます。ユーザーは一度に1つのオプションしか選択できません。
12	規模 スケールウィジェットは、スライダーウィジェットを提供するために使用されます。
13	スクロール・バー スクロールバーウィジェットは、リストボックスなどのさまざまなウィジェットにスクロール機能を追加するために使用されます。
14	テキスト テキストウィジェットは、テキストを複数行で表示するために使用されます。
15	トップレベル トップレベルウィジェットは、個別のウィンドウコンテナを提供するために使用されます。
16	スピンボックス Spinboxウィジェットは、標準のTkinter Entryウィジェットの変形であり、固定数の値から選択するために使用できます。
17	PanedWindow PanedWindowは、水平または垂直に配置された任意の数のペインを含むことができるコンテナウィジェットです。
18	ラベルフレーム ラベルフレームは単純なコンテナウィジェットです。その主な目的は、複雑なウィンドウレイアウトのスペーサーまたはコンテナーとして機能することです。
19	tkMessageBox このモジュールは、アプリケーションでメッセージボックスを表示するために使用されます。

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

標準属性

サイズ、色、フォントなど、それらの一般的な属性のいくつかがどのように指定されているかを見てみましょう。

• Dimensions

• Colors

• Fonts

• Anchors

• レリーフスタイル

• Bitmaps

• Cursors

それらを簡単に調べてみましょう-

ジオメトリ管理

すべてのTkinterウィジェットは、親ウィジェット領域全体でウィジェットを整理することを目的とした特定のジオメトリ管理メソッドにアクセスできます。Tkinterは、pack、grid、placeのジオメトリマネージャークラスを公開しています。

• パック（）メソッド-このジオメトリマネージャは、親ウィジェットでそれらを配置する前に、ブロック内のウィジェットを開催しています。

• グリッド（）メソッド-このジオメトリマネージャは、親ウィジェットにテーブル状の構造でウィジェットを整理します。

• 場所（）メソッドは、 -このジオメトリマネージャは、親ウィジェット内の特定の位置に置くことにより、ウィジェットを整理します。

ジオメトリ管理方法を簡単に調べてみましょう-

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

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

拡張機能を作成するための前提条件

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

• Unixマシンでは、これには通常、python2.5-devなどの開発者固有のパッケージをインストールする必要があります。

• Windowsユーザーは、バイナリPythonインストーラーを使用するときに、これらのヘッダーをパッケージの一部として取得します。

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

最初にPython拡張機能を見てください

Python拡張モジュールを初めて見るには、コードを4つの部分にグループ化する必要があります-

• ヘッダーファイルPython.h。

• モジュールからのインターフェースとして公開したいC関数。

• Python開発者が関数の名前を拡張モジュール内のC関数に表示するときに関数の名前をマッピングするテーブル。

• 初期化関数。

ヘッダーファイルPython.h

CソースファイルにPython.hヘッダーファイルをインクルードする必要があります。これにより、モジュールをインタープリターにフックするために使用される内部PythonAPIにアクセスできます。

必要になる可能性のある他のヘッダーの前に、必ず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と同等のCを返します。None値。Pythonヘッダーは、これを行うマクロPy_RETURN_NONEを定義します。

C関数の名前は、拡張モジュールの外部では表示されないため、好きな名前にすることができます。それらは静的関数として定義されています。

C関数は通常、ここに示すように、Pythonモジュール名と関数名を組み合わせて名前が付けられます。

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

これは、モジュールモジュール内の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とビット単位でOR演算できます。

  • これは、引数を受け入れたくないことを示す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ベースのシステムでは、site-packagesディレクトリに書き込む権限を取得するために、rootとしてこのコマンドを実行する必要があります。これは通常、Windowsでは問題になりません。

拡張機能のインポート

拡張機能をインストールすると、次のようにPythonスクリプトでその拡張機能をインポートして呼び出すことができます。

#!/usr/bin/python
import helloworld

print helloworld.helloworld()

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

Hello, Python extensions!!

関数パラメーターの受け渡し

引数を受け入れる関数を定義する可能性が高いため、C関数には他のシグネチャの1つを使用できます。たとえば、いくつかのパラメータを受け入れる次の関数は、次のように定義されます。

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引数です。これは、解析するオブジェクトです。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に等しくない値を返します。タプルは、C関数の2番目の引数であるPyObject *です。ここでのフォーマットは、必須およびオプションの引数を説明するC文字列です。

これがのフォーマットコードのリストです PyArg_ParseTuple 関数-

コード	Cタイプ	意味
c	char	長さ1のPython文字列はC文字になります。
d	ダブル	PythonフロートはCダブルになります。
f	浮く	PythonフロートはCフロートになります。
私	int	PythonintはCintになります。
l	長いです	PythonintはClongになります。
L	長い長い	PythonintはClonglongになります
O	PyObject *	Python引数へのNULL以外の借用参照を取得します。
s	char *	C char *にnullが埋め込まれていないPython文字列。
s＃	char * + int	Cアドレスと長さへのPython文字列。
t＃	char * + int	Cアドレスと長さへの読み取り専用の単一セグメントバッファ。
u	Py_UNICODE *	Cにnullが埋め込まれていないPythonUnicode。
u＃	Py_UNICODE * + int	Python UnicodeCのアドレスと長さ。
w＃	char * + int	シングルセグメントバッファをCアドレスと長さに読み取り/書き込みします。
z	char *	sと同様に、Noneも受け入れます（C char *をNULLに設定します）。
z＃	char * + int	s＃と同様に、Noneも受け入れます（C char *をNULLに設定します）。
（...）	のように...	Pythonシーケンスは、アイテムごとに1つの引数として扱われます。
|		次の引数はオプションです。
：		endをフォーマットし、その後にエラーメッセージの関数名を続けます。
;		終了をフォーマットし、その後にエラーメッセージテキスト全体を続けます。

戻り値

Py_BuildValueは、PyArg_ParseTupleと同じようにフォーマット文字列を取ります。構築している値のアドレスを渡す代わりに、実際の値を渡します。add関数を実装する方法を示す例を次に示します-

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,...)

ここでのフォーマットは、ビルドするPythonオブジェクトを説明するC文字列です。Py_BuildValueの次の引数は、結果の作成元となるC値です。PyObject *の結果は、新たなリファレンスです。

次の表に、一般的に使用されるコード文字列を示します。そのうちの0個以上が文字列形式に結合されています。

コード	Cタイプ	意味
c	char	AC文字は長さ1のPython文字列になります。
d	ダブル	ACdoubleはPythonフロートになります。
f	浮く	ACフロートはPythonフロートになります。
私	int	ACintはPythonintになります。
l	長いです	AClongはPythonintになります。
N	PyObject *	Pythonオブジェクトを渡し、参照を盗みます。
O	PyObject *	Pythonオブジェクトを渡し、通常どおりINCREFします。
O＆	convert + void *	任意の変換
s	char *	C0で終了するchar *からPython文字列、またはNULLからNone。
s＃	char * + int	C char *と長さをPython文字列に、またはNULLをNoneに。
u	Py_UNICODE *	C全体、nullで終了する文字列からPython Unicode、またはNULLからNone。
u＃	Py_UNICODE * + int	C全体の文字列と長さはPythonUnicodeに、NULLはNoneに。
w＃	char * + int	シングルセグメントバッファをCアドレスと長さに読み取り/書き込みします。
z	char *	sと同様に、Noneも受け入れます（C char *をNULLに設定します）。
z＃	char * + int	s＃と同様に、Noneも受け入れます（C char *をNULLに設定します）。
（...）	のように...	C値からPythonタプルを構築します。
[...]	のように...	C値からPythonリストを作成します。
{...}	のように...	C値、交互のキーと値からPython辞書を構築します。

コード{...}は、偶数のC値、交互にキーと値から辞書を作成します。たとえば、Py_BuildValue（ "{issi}"、23、 "zig"、 "zag"、42）は、Pythonの{23： 'zig'、 'zag'：42}のような辞書を返します。