Python3-クイックガイド

futureモジュール

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

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

from __future__ import division

印刷機能

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

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

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

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

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

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

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

In Python 2

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

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

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

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

In Python 3

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

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

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

整数除算

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

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

Unicode表現

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

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

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

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

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

例外を発生させる

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

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

例外の引数

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

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

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

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

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

2to3ユーティリティ

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

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

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

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

To convert into Python 3 version:

$2to3 -w area.py

Converted code :

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

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

Pythonは、高水準のインタープリター型のインタラクティブなオブジェクト指向スクリプト言語です。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 1.0は1994年11月にリリースされました。2000年に、Python2.0がリリースされました。Python 2.7.11は、Python2の最新版です。
一方、Python3.0は2008年にリリースされました。Python3はPython2との下位互換性がありません。Python3では、重複するプログラミング構造とモジュールを削除することに重点が置かれていたため、「1つ、できれば1つだけにする必要があります。それを行うための明白な方法。」Python 3.5.1は、Python3の最新バージョンです。

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には優れた機能の大きなリストがあります。A、以下にリストされているものはほとんどありません-

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

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

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

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

Pythonの入手

Windowsプラットフォーム

Python 3の最新バージョン（Python 3.5.1）のバイナリは、このダウンロードページから入手できます。

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

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

Note− Python 3.5.1をインストールするには、OSの最小要件はWindows7とSP1です。バージョン3.0から3.4.xの場合、WindowsXPが許容されます。

Linuxプラットフォーム

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

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

$sudo apt-get install python3-minimal

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

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

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

マックOS

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

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

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

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

Python Official Website − https://www.python.org/

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

Python Documentation Website− www.python.org/doc/

PATHの設定

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

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

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

Unix / Linuxでのパスの設定

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

In the csh shell − setenv PATH "$ PATH：/ usr / local / bin / python3"と入力し、Enterキーを押します。
In the bash shell (Linux) − export PYTHONPATH = / usr / local / bin / python3.4と入力し、Enterキーを押します。
In the sh or ksh shell − PATH = "$ PATH：/ usr / local / bin / python3"と入力し、Enterキーを押します。

Note − / usr / local / bin / python3は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 −以降の章に記載されているすべての例は、Windows7およびUbuntuLinuxで使用可能なPython3.4.1バージョンで実行されています。

理論を学びながら、利用可能なすべての例をオンラインで実行できるように、Pythonプログラミング環境をオンラインですでにセットアップしています。例を自由に変更して、オンラインで実行してください。

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

最初のPythonプログラム

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

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

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

$ python

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

On Windows:

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

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

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

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

Hello, Python!

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

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

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

print ("Hello, Python!")

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

On Linux

$ python test.py

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

Hello, Python!

On Windows

C:\Python34>Python test.py

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

Hello, Python!

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

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

file_finish = "end"
file_text = ""
contents=[]

file_name=input("Enter filename: ")
if len(file_name) == 0:
   print("Please enter filename")
   sys.exit()

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 = input("Enter text: ")
   contents.append(file_text)

   if file_text == file_finish:
      # close the file
      file.close()
      break

print(contents)
data = ' '.join([str(elem) for elem in contents])  
print(data)
file.write(data)
file.close()
file_name = input("Enter filename: ")

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

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

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

複数行のステートメント

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

total = item_one + \
        item_two + \
        item_three

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

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

Pythonでの引用

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

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

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

Pythonでのコメント

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

#!/usr/bin/python3

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

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

Hello, Python!

ステートメントまたは式の後に同じ行にコメントを入力できます-

name = "Madisetti" # This is again comment

Pythonには複数行のコメント機能はありません。次のように、各行に個別にコメントする必要があります-

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

空白行の使用

おそらくコメント付きの空白のみを含む行は空白行と呼ばれ、Pythonはそれを完全に無視します。

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

ユーザーを待っています

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

#!/usr/bin/python3

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変数は、メモリスペースを予約するために明示的な宣言を必要としません。変数に値を割り当てると、宣言が自動的に行われます。等号（=）は、変数に値を割り当てるために使用されます。

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

#!/usr/bin/python3

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

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

ここで、100、1000.0、および "John"は、それぞれcounter、miles、およびname変数に割り当てられた値です。これにより、次の結果が生成されます-

100
1000.0
John

複数の割り当て

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

For example −

a = b = c = 1

Here, an integer object is created with the value 1, and all the three variables are assigned to the same memory location. You can also assign multiple objects to multiple variables. For example −

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

Here, two integer objects with values 1 and 2 are assigned to the variables a and b respectively, and one string object with the value "john" is assigned to the variable c.

Standard Data Types

The data stored in memory can be of many types. For example, a person's age is stored as a numeric value and his or her address is stored as alphanumeric characters. Python has various standard data types that are used to define the operations possible on them and the storage method for each of them.

Python has five standard data types −

Numbers
String
List
Tuple
Dictionary

Python Numbers

Number data types store numeric values. Number objects are created when you assign a value to them. For example −

var1 = 1
var2 = 10

You can also delete the reference to a number object by using the del statement. The syntax of the del statement is −

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

You can delete a single object or multiple objects by using the del statement.

For example −

del var
del var_a, var_b

Python supports three different numerical types −

int (signed integers)
float (floating point real values)
complex (complex numbers)

All integers in Python3 are represented as long integers. Hence, there is no separate number type as long.

Examples

Here are some examples of numbers −

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

A complex number consists of an ordered pair of real floating-point numbers denoted by x + yj, where x and y are real numbers and j is the imaginary unit.

Python Strings

Strings in Python are identified as a contiguous set of characters represented in the quotation marks. Python allows either pair of single or double quotes. Subsets of strings can be taken using the slice operator ([ ] and [:] ) with indexes starting at 0 in the beginning of the string and working their way from -1 to the end.

The plus (+) sign is the string concatenation operator and the asterisk (*) is the repetition operator. For example −

#!/usr/bin/python3

str = 'Hello World!'

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

This will produce the following result −

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

Python Lists

Lists are the most versatile of Python's compound data types. A list contains items separated by commas and enclosed within square brackets ([]). To some extent, lists are similar to arrays in C. One of the differences between them is that all the items belonging to a list can be of different data type.

The values stored in a list can be accessed using the slice operator ([ ] and [:]) with indexes starting at 0 in the beginning of the list and working their way to end -1. The plus (+) sign is the list concatenation operator, and the asterisk (*) is the repetition operator. For example −

#!/usr/bin/python3

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

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

This produces the following result −

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

Python Tuples

A tuple is another sequence data type that is similar to the list. A tuple consists of a number of values separated by commas. Unlike lists, however, tuples are enclosed within parenthesis.

The main difference between lists and tuples are − Lists are enclosed in brackets ( [ ] ) and their elements and size can be changed, while tuples are enclosed in parentheses ( ( ) ) and cannot be updated. Tuples can be thought of as read-only lists. For example −

#!/usr/bin/python3

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

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

This produces the following result −

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

The following code is invalid with tuple, because we attempted to update a tuple, which is not allowed. Similar case is possible with lists −

#!/usr/bin/python3

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

Python Dictionary

Python's dictionaries are kind of hash-table type. They work like associative arrays or hashes found in Perl and consist of key-value pairs. A dictionary key can be almost any Python type, but are usually numbers or strings. Values, on the other hand, can be any arbitrary Python object.

Dictionaries are enclosed by curly braces ({ }) and values can be assigned and accessed using square braces ([]). For example −

#!/usr/bin/python3

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

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

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

This produces the following result −

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

Dictionaries have no concept of order among the elements. It is incorrect to say that the elements are "out of order"; they are simply unordered.

Data Type Conversion

Sometimes, you may need to perform conversions between the built-in types. To convert between types, you simply use the type-names as a function.

There are several built-in functions to perform conversion from one data type to another. These functions return a new object representing the converted value.

Sr.No.	Function & Description
1	int(x [,base]) Converts x to an integer. The base specifies the base if x is a string.
2	float(x) Converts x to a floating-point number.
3	complex(real [,imag]) Creates a complex number.
4	str(x) Converts object x to a string representation.
5	repr(x) Converts object x to an expression string.
6	eval(str) Evaluates a string and returns an object.
7	tuple(s) Converts s to a tuple.
8	list(s) Converts s to a list.
9	set(s) Converts s to a set.
10	dict(d) Creates a dictionary. d must be a sequence of (key,value) tuples.
11	frozenset(s) Converts s to a frozen set.
12	chr(x) Converts an integer to a character.
13	unichr(x) Converts an integer to a Unicode character.
14	ord(x) Converts a single character to its integer value.
15	hex(x) Converts an integer to a hexadecimal string.
16	oct(x) Converts an integer to an octal string.

Operators are the constructs, which can manipulate the value of operands. Consider the expression 4 + 5 = 9. Here, 4 and 5 are called the operands and + is called the operator.

Types of Operator

Python language supports the following types of operators −

Arithmetic Operators
Comparison (Relational) Operators
Assignment Operators
Logical Operators
Bitwise Operators
Membership Operators
Identity Operators

Let us have a look at all the operators one by one.

Python Arithmetic Operators

Assume variable a holds the value 10 and variable b holds the value 21, then −

Show Example

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

Python Comparison Operators

These operators compare the values on either side of them and decide the relation among them. They are also called Relational operators.

Assume variable a holds the value 10 and variable b holds the value 20, then −

Show Example

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

Python Assignment Operators

Assume variable a holds the value 10 and variable b holds the value 20, then −

Show Example

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

Python Bitwise Operators

Bitwise operator works on bits and performs bit-by-bit operation. Assume if a = 60; and b = 13; Now in binary format they will be as follows −

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

Python's built-in function bin() can be used to obtain binary representation of an integer number.

The following Bitwise operators are supported by Python language −

Show Example

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

Python Logical Operators

The following logical operators are supported by Python language. Assume variable a holds True and variable b holds False then −

Show Example

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

Python Membership Operators

Python’s membership operators test for membership in a sequence, such as strings, lists, or tuples. There are two membership operators as explained below −

Show Example

Operator	Description	Example
in	Evaluates to true if it finds a variable in the specified sequence and false otherwise.	x in y, here in results in a 1 if x is a member of sequence y.
not in	Evaluates to true if it does not finds a variable in the specified sequence and false otherwise.	x not in y, here not in results in a 1 if x is not a member of sequence y.

Python Identity Operators

Identity operators compare the memory locations of two objects. There are two Identity operators as explained below −

Show Example

Operator	Description	Example
is	Evaluates to true if the variables on either side of the operator point to the same object and false otherwise.	x is y, here is results in 1 if id(x) equals id(y).
is not	Evaluates to false if the variables on either side of the operator point to the same object and true otherwise.	x is not y, here is not results in 1 if id(x) is not equal to id(y).

Python演算子の優先順位

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

例を表示

シニア番号	オペレーターと説明
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 values FALSE値として。

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

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

それぞれの意思決定ステートメントをすばやく確認しましょう。

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

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

例

これはの例です one-line if 条項-

#!/usr/bin/python3

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

出力

上記のコードを実行すると、次の結果が得られます。

Value of expression is 100
Good bye!

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

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

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

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

シニア番号	ループの種類と説明
1	whileループ指定された条件がTRUEである間、ステートメントまたはステートメントのグループを繰り返します。ループ本体を実行する前に条件をテストします。
2	forループ一連のステートメントを複数回実行し、ループ変数を管理するコードを省略します。
3	ネストされたループ 1つ以上のループを別のwhileまたはforループ内で使用できます。

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

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

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

シニア番号	制御ステートメントと説明
1	breakステートメントループステートメントを終了し、ループの直後のステートメントに実行を転送します。
2	ステートメントを続けるループに本体の残りの部分をスキップさせ、繰り返す前にすぐにその状態を再テストします。
3	passステートメント Pythonのpassステートメントは、ステートメントが構文的に必要であるが、コマンドやコードを実行したくない場合に使用されます。

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

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

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

文字列、リスト、またはタプルオブジェクトを使用して、イテレータを作成できます。

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

A generator は、yieldメソッドを使用して一連の値を生成または生成する関数です。

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

例

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

#!usr/bin/python3

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

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

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

数値オブジェクトに値を割り当てると、それらが作成されます。例-

var1 = 1
var2 = 10

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

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

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

del var
del var_a, var_b

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

int (signed integers) −それらはしばしば単に整数または ints。それらは、小数点のない正または負の整数です。Python3の整数のサイズは無制限です。Python 2には、intとlongの2つの整数型があります。ありません 'long integer'Python3ではもう。
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プログラミングでは、複素数はあまり使用されません。

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

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

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

例

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

int	浮く	繁雑
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3 + e18	.876j
-0490	-90。	-.6545 + 0J
-0×260	-32.54e100	3e + 26J
0×69	70.2-E12	4.53e-7j

複素数は、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。 Deprecated Python3で。代わりに return (x>y)-(x<y)。
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]）範囲（開始、停止、ステップ）からランダムに選択された要素。
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/python3

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

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

上記のコードを実行すると、次の結果が得られます。

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

文字列の更新

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

#!/usr/bin/python3

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

上記のコードを実行すると、次の結果が得られます。

Updated String :-  Hello Python

エスケープ文字

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

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

バックスラッシュ表記	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/python3

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

上記のコードを実行すると、次の結果が得られます。

My name is Zara and weight is 21 kg!

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

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

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

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

トリプルクォート

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

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

#!/usr/bin/python3

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

上記のコードを実行すると、次のような結果になります。「上」の間の文字列の最後にある最後の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.

Raw strings do not treat the backslash as a special character at all. Every character you put into a raw string stays the way you wrote it −

#!/usr/bin/python3

print ('C:\\nowhere')

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

C:\nowhere

Now let's make use of raw string. We would put expression in r'expression' as follows −

#!/usr/bin/python3

print (r'C:\\nowhere')

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

C:\\nowhere

Unicode String

In Python 3, all strings are represented in Unicode.In Python 2 are stored internally as 8-bit ASCII, hence it is required to attach 'u' to make it Unicode. It is no longer necessary now.

Built-in String Methods

Python includes the following built-in methods to manipulate strings −

Sr.No.	Methods & Description
1	capitalize() Capitalizes first letter of string
2	center(width, fillchar) Returns a string padded with fillchar with the original string centered to a total of width columns.
3	count(str, beg = 0,end = len(string)) Counts how many times str occurs in string or in a substring of string if starting index beg and ending index end are given.
4	decode(encoding = 'UTF-8',errors = 'strict') Decodes the string using the codec registered for encoding. encoding defaults to the default string encoding.
5	encode(encoding = 'UTF-8',errors = 'strict') Returns encoded string version of string; on error, default is to raise a ValueError unless errors is given with 'ignore' or 'replace'.
6	endswith(suffix, beg = 0, end = len(string)) Determines if string or a substring of string (if starting index beg and ending index end are given) ends with suffix; returns true if so and false otherwise.
7	expandtabs(tabsize = 8) Expands tabs in string to multiple spaces; defaults to 8 spaces per tab if tabsize not provided.
8	find(str, beg = 0 end = len(string)) Determine if str occurs in string or in a substring of string if starting index beg and ending index end are given returns index if found and -1 otherwise.
9	index(str, beg = 0, end = len(string)) Same as find(), but raises an exception if str not found.
10	isalnum() Returns true if string has at least 1 character and all characters are alphanumeric and false otherwise.
11	isalpha() Returns true if string has at least 1 character and all characters are alphabetic and false otherwise.
12	isdigit() Returns true if string contains only digits and false otherwise.
13	islower() Returns true if string has at least 1 cased character and all cased characters are in lowercase and false otherwise.
14	isnumeric() Returns true if a unicode string contains only numeric characters and false otherwise.
15	isspace() Returns true if string contains only whitespace characters and false otherwise.
16	istitle() Returns true if string is properly "titlecased" and false otherwise.
17	isupper() Returns true if string has at least one cased character and all cased characters are in uppercase and false otherwise.
18	join(seq) Merges (concatenates) the string representations of elements in sequence seq into a string, with separator string.
19	len(string) Returns the length of the string
20	ljust(width[, fillchar]) Returns a space-padded string with the original string left-justified to a total of width columns.
21	lower() Converts all uppercase letters in string to lowercase.
22	lstrip() Removes all leading whitespace in string.
23	maketrans() Returns a translation table to be used in translate function.
24	max(str) Returns the max alphabetical character from the string str.
25	min(str) Returns the min alphabetical character from the string str.
26	replace(old, new [, max]) Replaces all occurrences of old in string with new or at most max occurrences if max given.
27	rfind(str, beg = 0,end = len(string)) Same as find(), but search backwards in string.
28	rindex( str, beg = 0, end = len(string)) Same as index(), but search backwards in string.
29	rjust(width,[, fillchar]) Returns a space-padded string with the original string right-justified to a total of width columns.
30	rstrip() Removes all trailing whitespace of string.
31	split(str="", num=string.count(str)) Splits string according to delimiter str (space if not provided) and returns list of substrings; split into at most num substrings if given.
32	splitlines( num=string.count('\n')) Splits string at all (or num) NEWLINEs and returns a list of each line with NEWLINEs removed.
33	startswith(str, beg=0,end=len(string)) Determines if string or a substring of string (if starting index beg and ending index end are given) starts with substring str; returns true if so and false otherwise.
34	strip([chars]) Performs both lstrip() and rstrip() on string
35	swapcase() Inverts case for all letters in string.
36	title() Returns "titlecased" version of string, that is, all words begin with uppercase and the rest are lowercase.
37	translate(table, deletechars="") Translates string according to translation table str(256 chars), removing those in the del string.
38	upper() Converts lowercase letters in string to uppercase.
39	zfill (width) Returns original string leftpadded with zeros to a total of width characters; intended for numbers, zfill() retains any sign given (less one zero).
40	isdecimal() Returns true if a unicode string contains only decimal characters and false otherwise.

The most basic data structure in Python is the sequence. Each element of a sequence is assigned a number - its position or index. The first index is zero, the second index is one, and so forth.

Python has six built-in types of sequences, but the most common ones are lists and tuples, which we would see in this tutorial.

There are certain things you can do with all the sequence types. These operations include indexing, slicing, adding, multiplying, and checking for membership. In addition, Python has built-in functions for finding the length of a sequence and for finding its largest and smallest elements.

Python Lists

The list is the most versatile datatype available in Python, which can be written as a list of comma-separated values (items) between square brackets. Important thing about a list is that the items in a list need not be of the same type.

Creating a list is as simple as putting different comma-separated values between square brackets. For example −

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

Similar to string indices, list indices start at 0, and lists can be sliced, concatenated and so on.

Accessing Values in Lists

To access values in lists, use the square brackets for slicing along with the index or indices to obtain value available at that index. For example −

#!/usr/bin/python3

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

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

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

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

Updating Lists

You can update single or multiple elements of lists by giving the slice on the left-hand side of the assignment operator, and you can add to elements in a list with the append() method. For example −

#!/usr/bin/python3

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

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

Note − The append() method is discussed in the subsequent section.

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

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

Delete List Elements

To remove a list element, you can use either the del statement if you know exactly which element(s) you are deleting. You can use the remove() method if you do not know exactly which items to delete. For example −

#!/usr/bin/python3

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

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

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

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

Note − remove() method is discussed in subsequent section.

Basic List Operations

Lists respond to the + and * operators much like strings; they mean concatenation and repetition here too, except that the result is a new list, not a string.

In fact, lists respond to all of the general sequence operations we used on strings in the prior chapter.

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

Indexing, Slicing and Matrixes

Since lists are sequences, indexing and slicing work the same way for lists as they do for strings.

Assuming the following input −

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

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

Built-in List Functions and Methods

Python includes the following list functions −

Sr.No.	Function & Description
1	len(list) Gives the total length of the list.
2	max(list) Returns item from the list with max value.
3	min(list) Returns item from the list with min value.
4	list(seq) Converts a tuple into list.

Python includes the following list methods −

Sr.No.	Methods & Description
1	list.append(obj) Appends object obj to list
2	list.count(obj) Returns count of how many times obj occurs in list
3	list.extend(seq) Appends the contents of seq to list
4	list.index(obj) Returns the lowest index in list that obj appears
5	list.insert(index, obj) Inserts object obj into list at offset index
6	list.pop(obj = list[-1]) Removes and returns last object or obj from list
7	list.remove(obj) Removes object obj from list
8	list.reverse() Reverses objects of list in place
9	list.sort([func]) Sorts objects of list, use compare func if given

A tuple is a collection of objects which ordered and immutable. Tuples are sequences, just like lists. The main difference between the tuples and the lists is that the tuples cannot be changed unlike lists. Tuples use parentheses, whereas lists use square brackets.

Creating a tuple is as simple as putting different comma-separated values. Optionally, you can put these comma-separated values between parentheses also. For example −

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

The empty tuple is written as two parentheses containing nothing −

tup1 = ();

To write a tuple containing a single value you have to include a comma, even though there is only one value −

tup1 = (50,)

Like string indices, tuple indices start at 0, and they can be sliced, concatenated, and so on.

Accessing Values in Tuples

To access values in tuple, use the square brackets for slicing along with the index or indices to obtain the value available at that index. For example −

#!/usr/bin/python3

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

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

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

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

Updating Tuples

Tuples are immutable, which means you cannot update or change the values of tuple elements. You are able to take portions of the existing tuples to create new tuples as the following example demonstrates −

#!/usr/bin/python3

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

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

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

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

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

Delete Tuple Elements

Removing individual tuple elements is not possible. There is, of course, nothing wrong with putting together another tuple with the undesired elements discarded.

To explicitly remove an entire tuple, just use the del statement. For example −

#!/usr/bin/python3

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

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

This produces the following result.

Note − An exception is raised. This is because after del tup, tuple does not exist any more.

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

Basic Tuples Operations

Tuples respond to the + and * operators much like strings; they mean concatenation and repetition here too, except that the result is a new tuple, not a string.

In fact, tuples respond to all of the general sequence operations we used on strings in the previous chapter.

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

Indexing, Slicing, and Matrixes

Since tuples are sequences, indexing and slicing work the same way for tuples as they do for strings, assuming the following input −

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

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

No Enclosing Delimiters

No enclosing Delimiters is any set of multiple objects, comma-separated, written without identifying symbols, i.e., brackets for lists, parentheses for tuples, etc., default to tuples, as indicated in these short examples.

Built-in Tuple Functions

Python includes the following tuple functions −

Sr.No.	Function & Description
1	cmp(tuple1, tuple2) Compares elements of both tuples.
2	len(tuple) Gives the total length of the tuple.
3	max(tuple) Returns item from the tuple with max value.
4	min(tuple) Returns item from the tuple with min value.
5	tuple(seq) Converts a list into tuple.

Each key is separated from its value by a colon (:), the items are separated by commas, and the whole thing is enclosed in curly braces. An empty dictionary without any items is written with just two curly braces, like this: {}.

Keys are unique within a dictionary while values may not be. The values of a dictionary can be of any type, but the keys must be of an immutable data type such as strings, numbers, or tuples.

Accessing Values in Dictionary

To access dictionary elements, you can use the familiar square brackets along with the key to obtain its value. Following is a simple example −

#!/usr/bin/python3

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

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

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

If we attempt to access a data item with a key, which is not a part of the dictionary, we get an error as follows −

#!/usr/bin/python3

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

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

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

Updating Dictionary

You can update a dictionary by adding a new entry or a key-value pair, modifying an existing entry, or deleting an existing entry as shown in a simple example given below.

#!/usr/bin/python3

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

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

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

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

Delete Dictionary Elements

You can either remove individual dictionary elements or clear the entire contents of a dictionary. You can also delete entire dictionary in a single operation.

To explicitly remove an entire dictionary, just use the del statement. Following is a simple example −

#!/usr/bin/python3

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

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

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

This produces the following result.

An exception is raised because after del dict, the dictionary does not exist anymore.

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 − The del() method is discussed in subsequent section.

Properties of Dictionary Keys

Dictionary values have no restrictions. They can be any arbitrary Python object, either standard objects or user-defined objects. However, same is not true for the keys.

There are two important points to remember about dictionary keys −

(a) More than one entry per key is not allowed. This means no duplicate key is allowed. When duplicate keys are encountered during assignment, the last assignment wins. For example −

#!/usr/bin/python3

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

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

dict['Name']:  Manni

(b) Keys must be immutable. This means you can use strings, numbers or tuples as dictionary keys but something like ['key'] is not allowed. Following is a simple example −

#!/usr/bin/python3

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

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

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

Built-in Dictionary Functions and Methods

Python includes the following dictionary functions −

Sr.No.	Function & Description
1	cmp(dict1, dict2) No longer available in Python 3.
2	len(dict) Gives the total length of the dictionary. This would be equal to the number of items in the dictionary.
3	str(dict) Produces a printable string representation of a dictionary
4	type(variable) Returns the type of the passed variable. If passed variable is dictionary, then it would return a dictionary type.

Python includes the following dictionary methods −

Sr.No.	Method & Description
1	dict.clear() Removes all elements of dictionary dict
2	dict.copy() Returns a shallow copy of dictionary dict
3	dict.fromkeys() Create a new dictionary with keys from seq and values set to value.
4	dict.get(key, default=None) For key key, returns value or default if key not in dictionary
5	dict.has_key(key) Removed, use the in operation instead.
6	dict.items() Returns a list of dict's (key, value) tuple pairs
7	dict.keys() Returns list of dictionary dict's keys
8	dict.setdefault(key, default = None) Similar to get(), but will set dict[key] = default if key is not already in dict
9	dict.update(dict2) Adds dictionary dict2's key-values pairs to dict
10	dict.values() Returns list of dictionary dict's values

A Python program can handle date and time in several ways. Converting between date formats is a common chore for computers. Python's time and calendar modules help track dates and times.

What is Tick?

Time intervals are floating-point numbers in units of seconds. Particular instants in time are expressed in seconds since 12:00am, January 1, 1970(epoch).

There is a popular time module available in Python which provides functions for working with times, and for converting between representations. The function time.time() returns the current system time in ticks since 12:00am, January 1, 1970(epoch).

Example

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

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

This would produce a result something as follows −

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

Date arithmetic is easy to do with ticks. However, dates before the epoch cannot be represented in this form. Dates in the far future also cannot be represented this way - the cutoff point is sometime in 2038 for UNIX and Windows.

What is TimeTuple?

Many of the Python's time functions handle time as a tuple of 9 numbers, as shown below −

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

For Example −

import time

print (time.localtime());

This would produce a result as follows −

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

The above tuple is equivalent to struct_time structure. This structure has following attributes −

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

Getting current time

To translate a time instant from seconds since the epoch floating-point value into a timetuple, pass the floating-point value to a function (e.g., localtime) that returns a time-tuple with all valid nine items.

#!/usr/bin/python3
import time

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

This would produce the following result, which could be formatted in any other presentable form −

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

Getting formatted time

You can format any time as per your requirement, but a simple method to get time in a readable format is asctime() −

ライブデモ

#!/usr/bin/python3
import time

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

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

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

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

カレンダーモジュールは、年次および月次カレンダーを操作するためのさまざまな方法を提供します。ここでは、特定の月（2008年1月）のカレンダーを印刷します-

#!/usr/bin/python3
import calendar

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

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

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

時間モジュール

人気があります timePythonで利用可能なモジュールで、時間の操作や表現間の変換のための関数を提供します。これが利用可能なすべての方法のリストです。

シニア番号	機能と説明
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）呼び出し元のスレッドをsecs秒間中断します。
9	time.strftime（fmt [、tupletime]）現地時間のタイムタプルとして表されるインスタントを受け入れ、文字列fmtで指定されたインスタントを表す文字列を返します。
10	time.strptime（str、fmt = '％a％b％d％H：％M：％S％Y'）フォーマット文字列fmtに従ってstrを解析し、タイムタプル形式でインスタントを返します。
11	time.time（）現在の時刻、エポックからの浮動小数点秒数を返します。
12	time.tzset（）ライブラリルーチンで使用される時間変換ルールをリセットします。環境変数TZは、これがどのように行われるかを指定します。

時間モジュールで使用できる2つの重要な属性があります。彼らは-

シニア番号	属性と説明
1	time.timezone 属性time.timezoneは、UTCからのローカルタイムゾーン（DSTなし）の秒単位のオフセットです（南北アメリカでは> 0、ヨーロッパ、アジア、アフリカのほとんどでは<= 0）。
2	time.tzname 属性time.tznameは、ロケールに依存する文字列のペアです。これらは、それぞれDSTがない場合とある場合のローカルタイムゾーンの名前です。

カレンダーモジュール

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

デフォルトでは、カレンダーは月曜日を週の最初の日として、日曜日を最後の日として取ります。これを変更するには、calendar.setfirstweekday() 関数。

これはで利用可能な機能のリストです calendar モジュール-

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

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

興味があれば、ここにPythonで日付と時刻を操作するための他の重要なモジュールと関数のリストがあります-

日時モジュール
pytzモジュール
dateutilモジュール

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

ご存知のように、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/python3

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

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

上記のコードを実行すると、次の結果が得られます。

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

参照渡しと値

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

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("Values inside the function before change: ", mylist)
   mylist[2]=50
   print ("Values inside the function after change: ", mylist)
   return

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

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

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

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

#!/usr/bin/python3

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

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

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

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

関数の引数

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

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

必要な引数

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

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

#!/usr/bin/python3

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

# Now you can call printme function
printme()

上記のコードを実行すると、次の結果が得られます。

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

キーワード引数

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

これにより、Pythonインタープリターは提供されたキーワードを使用して値をパラメーターと照合できるため、引数をスキップしたり、順序を狂わせたりすることができます。にキーワード呼び出しを行うこともできますprintme() 次のように機能します-

#!/usr/bin/python3

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

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

上記のコードを実行すると、次の結果が得られます。

My string

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

#!/usr/bin/python3

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

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

上記のコードを実行すると、次の結果が得られます。

Name:  miki
Age  50

デフォルトの引数

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

#!/usr/bin/python3

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

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

上記のコードを実行すると、次の結果が得られます。

Name:  miki
Age  50
Name:  miki
Age  35

可変長引数

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

キーワード以外の可変引数を持つ関数の構文を以下に示します-

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

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

#!/usr/bin/python3

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

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

上記のコードを実行すると、次の結果が得られます。

Output is:
10
Output is:
70
60
50

匿名関数

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

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

構文

の構文 lambda 関数には、次のような1つのステートメントのみが含まれます。

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

以下は、その方法を示す例です。 lambda 関数の形式は機能します-

#!/usr/bin/python3

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

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

上記のコードを実行すると、次の結果が得られます。

Value of total :  30
Value of total :  40

returnステートメント

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

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

#!/usr/bin/python3

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

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

上記のコードを実行すると、次の結果が得られます。

Inside the function :  30
Outside the function :  30

変数の範囲

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

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

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

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

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

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

#!/usr/bin/python3

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

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

上記のコードを実行すると、次の結果が得られます。

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

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

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

例

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

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

輸入声明

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

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

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

#!/usr/bin/python3

# Import module support
import support

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

上記のコードを実行すると、次の結果が得られます。

Hello : Zara

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

from ... importステートメント

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

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

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

#!/usr/bin/python3

# Fibonacci numbers module

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

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

from ... import *ステートメント

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

from modname import *

これにより、モジュールから現在の名前空間にすべてのアイテムをインポートする簡単な方法が提供されます。ただし、このステートメントは慎重に使用する必要があります。

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

モジュール内では、モジュールの名前（文字列として）がグローバル変数__name__の値として使用できます。モジュール内のコードは、インポートした場合と同じように実行されますが、__ name__は「__main__」に設定されています。

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

#!/usr/bin/python3

# Fibonacci numbers module

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

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

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

モジュールの検索

モジュールをインポートすると、Pythonインタープリターは次の順序でモジュールを検索します-

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

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

PYTHONPATH変数

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

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

set PYTHONPATH = c:\python34\lib;

そしてこれがUNIXシステムからの典型的なPYTHONPATHです-

set PYTHONPATH = /usr/local/lib/python

名前空間とスコープ

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

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

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

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

#!/usr/bin/python3

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

print (Money)
AddMoney()
print (Money)

dir（）関数

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

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

#!/usr/bin/python3

# Import built-in module math
import math

content = dir(math)
print (content)

上記のコードを実行すると、次の結果が得られます。

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

ここで、特別な文字列変数__name__はモジュールの名前であり、__ file__はモジュールがロードされたファイル名です。

globals（）およびlocals（）関数

ザ・ globals() そして locals() 関数を使用して、呼び出された場所に応じて、グローバル名前空間とローカル名前空間の名前を返すことができます。

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

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

reload（）関数

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

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

reload(module_name)

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

reload(hello)

Pythonのパッケージ

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

電話帳にあるPots.pyファイルについて考えてみます。このファイルには、次のソースコード行があります-

#!/usr/bin/python3

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

# Now import your Phone Package.
import Phone

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

上記のコードを実行すると、次の結果が得られます。

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

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

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

画面への印刷

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

#!/usr/bin/python3

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

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

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

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

Python 2には、標準入力からデータを読み取るための2つの組み込み関数があります。これは、デフォルトではキーボードからのものです。これらの機能はinput() そして raw_input()

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

入力関数

ザ・ input([prompt]) 関数は、入力が有効なPython式であると想定し、評価された結果を返すことを除いて、raw_inputと同等です。

#!/usr/bin/python3

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

>>> x
'10'

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

>>> x
"'10'"

ファイルを開いたり閉じたりする

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

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

オープン機能

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

構文

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

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

file_name − file_name引数は、アクセスするファイルの名前を含む文字列値です。
access_mode− access_modeは、ファイルを開く必要のあるモード（読み取り、書き込み、追加など）を決定します。可能な値の完全なリストを以下の表に示します。これはオプションのパラメーターであり、デフォルトのファイルアクセスモードが読み取られます（r）。
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 ファイルの名前を返します。

Note −softspace属性はPython3.xではサポートされていません

例

#!/usr/bin/python3

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

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

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

close（）メソッド

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

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

構文

fileObject.close();

例

#!/usr/bin/python3

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

# Close opened file
fo.close()

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

Name of the file:  foo.txt

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

ファイルオブジェクトは、私たちの生活を楽にするための一連のアクセスメソッドを提供します。使い方がわかりますread() そして write() ファイルを読み書きするメソッド。

write（）メソッド

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

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

構文

fileObject.write(string);

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

例

#!/usr/bin/python3

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

# Close opend file
fo.close()

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

Python is a great language.
Yeah its great!!

read（）メソッド

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

構文

fileObject.read([count]);

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

例

上で作成したfoo.txtファイルを取り上げましょう。

#!/usr/bin/python3

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

# Close opened file
fo.close()

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

Read String is :  Python is

ファイルの位置

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

シーク（オフセット[、から]）メソッドは、現在のファイル位置を変更します。ザ・offset引数は、移動するバイト数を示します。ザ・from 引数は、バイトが移動される参照位置を指定します。

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

例

上で作成したfoo.txtファイルを取り上げましょう。

#!/usr/bin/python3

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

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

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

# Close opened file
fo.close()

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

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

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

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

このモジュールを使用するには、最初にモジュールをインポートしてから、関連する関数を呼び出す必要があります。

rename（）メソッド

ザ・ rename() メソッドは、現在のファイル名と新しいファイル名の2つの引数を取ります。

構文

os.rename(current_file_name, new_file_name)

例

以下は、既存のファイルの名前を変更する例であるtest1.txtというの-

#!/usr/bin/python3
import os

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

remove（）メソッド

あなたは使用することができます remove() 削除するファイルの名前を引数として指定してファイルを削除する方法。

構文

os.remove(file_name)

例

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

#!/usr/bin/python3
import os

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

Pythonのディレクトリ

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

mkdir（）メソッド

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

構文

os.mkdir("newdir")

例

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

#!/usr/bin/python3
import os

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

chdir（）メソッド

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

構文

os.chdir("newdir")

例

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

#!/usr/bin/python3
import os

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

getcwd（）メソッド

ザ・ getcwd() メソッドは、現在の作業ディレクトリを表示します。

構文

os.getcwd()

例

以下は、現在のディレクトリを指定する例です-

#!/usr/bin/python3
import os

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

rmdir（）メソッド

ザ・ rmdir() メソッドは、メソッドの引数として渡されたディレクトリを削除します。

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

構文

os.rmdir('dirname')

例

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

#!/usr/bin/python3
import os

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

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

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

ファイルオブジェクトメソッド

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

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

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

Exception Handling−これはこのチュートリアルでカバーされます。Pythonで利用可能な標準例外のリスト-標準例外は次のとおりです。
Assertions−これはPython3チュートリアルのアサーションでカバーされます。

標準例外

Pythonで利用可能な標準例外のリストは次のとおりです。−

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

Pythonでのアサーション

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

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

assertステートメント

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

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

assert Expression[, Arguments]

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

例

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

#!/usr/bin/python3

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

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

上記のコードを実行すると、次の結果が得られます。

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

例外とは何ですか？

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

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

例外の処理

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

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

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

Written content in the file successfully

例

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

#!/usr/bin/python3

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

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

Error: can't find file or read data

例外のない例外条項

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

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

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

複数の例外がある例外条項

次のように、同じexceptステートメントを使用して複数の例外を処理することもできます。

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:ブロック。ザ・finally:blockは、try-blockで例外が発生したかどうかに関係なく、実行する必要のあるコードを配置する場所です。try-finallyステートメントの構文は次のとおりです-

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

Note−except節またはfinally節を指定できますが、両方を指定することはできません。else句をfinally句と一緒に使用することはできません。

例

#!/usr/bin/python3

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

書き込みモードでファイルを開く権限がない場合、次の結果が生成されます-

Error: can't find file or read data

同じ例を次のようにすっきりと書くことができます−

#!/usr/bin/python3

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

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

Going to close the file

tryブロックで例外がスローされると、実行はすぐにfinallyブロックに渡されます。finishブロック内のすべてのステートメントが実行された後、例外が再度発生し、try-exceptステートメントの次の上位層に存在する場合はexceptステートメントで処理されます。

例外の引数

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

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

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

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

例

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

#!/usr/bin/python3

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

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

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

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

例外を発生させる

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

構文

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

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

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

例

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

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

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

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

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

#!/usr/bin/python3

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

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

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

error in level argument -10

ユーザー定義の例外

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

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

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

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

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

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

Pythonは、存在して以来、オブジェクト指向言語でした。このため、クラスとオブジェクトの作成と使用は非常に簡単です。この章は、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は、このクラスのaのすべてのインスタンス間で値が共有されるクラス変数です。これは、クラス内またはクラス外から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/python3

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

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

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


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

上記のコードを実行すると、次の結果が得られます。

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

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

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

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

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

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

組み込みのクラス属性

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

__dict__ −クラスの名前空間を含む辞書。
__doc__ −クラスドキュメント文字列、または未定義の場合はなし。
__name__ −クラス名。
__module__−クラスが定義されているモジュール名。この属性は、インタラクティブモードでは「__main__」です。
__bases__ −基本クラスリストに出現する順序で、基本クラスを含む空の可能性のあるタプル。

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

#!/usr/bin/python3

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

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

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

emp1 = Employee("Zara", 2000)
emp2 = Employee("Manni", 5000)
print ("Employee.__doc__:", Employee.__doc__)
print ("Employee.__name__:", Employee.__name__)
print ("Employee.__module__:", Employee.__module__)
print ("Employee.__bases__:", Employee.__bases__)
print ("Employee.__dict__:", Employee.__dict__ )

上記のコードを実行すると、次の結果が得られます。

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: (<class 'object'>,)
Employee.__dict__: {
   'displayCount': <function Employee.displayCount at 0x0160D2B8>, 
   '__module__': '__main__', '__doc__': 'Common base class for all employees', 
   'empCount': 2, '__init__': 
   <function Employee.__init__ at 0x0124F810>, 'displayEmployee': 
   <function Employee.displayEmployee at 0x0160D300>,
   '__weakref__': 
   <attribute '__weakref__' of 'Employee' objects>, '__dict__': 
   <attribute '__dict__' of 'Employee' objects>
}

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

Pythonは、不要なオブジェクト（組み込み型またはクラスインスタンス）を自動的に削除して、メモリスペースを解放します。Pythonが、使用されなくなったメモリのブロックを定期的に再利用するプロセスは、ガベージコレクションと呼ばれます。

Pythonのガベージコレクターはプログラムの実行中に実行され、オブジェクトの参照カウントがゼロに達するとトリガーされます。オブジェクトを指すエイリアスの数が変わると、オブジェクトの参照カウントも変わります。

オブジェクトに新しい名前が割り当てられるか、コンテナ（リスト、タプル、またはディクショナリ）に配置されると、オブジェクトの参照カウントが増加します。オブジェクトの参照カウントは、delで削除された場合、参照が再割り当てされた場合、または参照がスコープ外になると減少します。オブジェクトの参照カウントがゼロに達すると、Pythonはそれを自動的に収集します。

a = 40      # Create object <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/python3

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print (class_name, "destroyed")

pt1 = Point()
pt2 = pt1
pt3 = pt1
print (id(pt1), id(pt2), id(pt3))   # prints the ids of the obejcts
del pt1
del pt2
del pt3

上記のコードを実行すると、次の結果が得られます。

140338326963984 140338326963984 140338326963984
Point destroyed

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

上記の例では、Pointクラスの定義がpoint.pyに含まれていて、他の実行可能コードが含まれていないと仮定しています。

#!/usr/bin/python3
import point

p1 = point.Point()

クラスの継承

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

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

構文

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

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

例

#!/usr/bin/python3

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print ("Calling parent constructor")

   def parentMethod(self):
      print ('Calling parent method')

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print ("Parent attribute :", Parent.parentAttr)

class Child(Parent): # define child class
   def __init__(self):
      print ("Calling child constructor")

   def childMethod(self):
      print ('Calling child method')

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method

上記のコードを実行すると、次の結果が得られます。

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

同様の方法で、次のように複数の親クラスからクラスを駆動できます。

class A:        # define your class A
.....

class B:         # define your calss B
.....

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

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

ザ・ issubclass(sub, sup) 指定されたサブクラスの場合、ブール関数はTrueを返します sub 確かにスーパークラスのサブクラスです sup。
ザ・ isinstance(obj, Class)objがクラスClassのインスタンスであるか、Classのサブクラスのインスタンスである場合、ブール関数はTrueを返します。

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

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

例

#!/usr/bin/python3

class Parent:        # define parent class
   def myMethod(self):
      print ('Calling parent method')

class Child(Parent): # define child class
   def myMethod(self):
      print ('Calling child method')

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

上記のコードを実行すると、次の結果が得られます。

Calling child method

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

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

シニア番号	メソッド、説明、サンプルコール
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/python3

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

上記のコードを実行すると、次の結果が得られます。

Vector(7,8)

データの隠蔽

オブジェクトの属性は、クラス定義の外部に表示される場合と表示されない場合があります。二重下線プレフィックスを付けて属性に名前を付ける必要があります。そうすると、それらの属性は部外者に直接表示されなくなります。

例

#!/usr/bin/python3

class JustCounter:
   __secretCount = 0
  
   def count(self):
      self.__secretCount += 1
      print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.__secretCount)

上記のコードを実行すると、次の結果が得られます。

1
2
Traceback (most recent call last):
   File "test.py", line 12, in <module>
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Pythonは、クラス名を含むように名前を内部的に変更することにより、これらのメンバーを保護します。object._className__attrNameなどの属性にアクセスできます。次のように最後の行を置き換える場合、それはあなたのために働きます-

.........................
print (counter._JustCounter__secretCount)

上記のコードを実行すると、次の結果が得られます。

1
2
2

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

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

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

単一文字に一致する基本パターン

シニア番号	式と一致
1	a, X, 9, < 普通のキャラクターは自分と完全に一致します。
2	. (a period) 改行を除くすべての単一文字に一致します '\ n'
3	\w 「単語」文字に一致します：文字または数字またはアンダーバー[a-zA-Z0-9_]。
4	\W 単語以外の文字と一致します。
5	\b 単語と非単語の境界
6	\s 単一の空白文字（スペース、改行、リターン、タブ）に一致します
7	\S 空白以外の文字と一致します。
8	\t, \n, \r タブ、改行、戻る
9	\d 10進数[0-9]
10	^ 文字列の先頭に一致します
11	$ 文字列の終わりに一致する
12	\ キャラクターの「特殊性」を抑制します。

コンパイルフラグ

コンパイルフラグを使用すると、正規表現の動作のいくつかの側面を変更できます。フラグは、reモジュールで2つの名前（次のような長い名前）で使用できます。IGNORECASE そして、Iのような短い1文字のフォーム。

シニア番号	フラグと意味
1	ASCII, A \ w、\ b、\ s、\ dのようないくつかのエスケープを、それぞれのプロパティを持つASCII文字でのみ一致させます。
2	DOTALL, S 改行を含む任意の文字を作成し、一致させます
3	IGNORECASE, I 大文字と小文字を区別しない一致を行う
4	LOCALE, L ロケールを意識した照合を行う
5	MULTILINE, M ^と$に影響する複数行のマッチング
6	VERBOSE, X (for ‘extended’) よりクリーンで理解しやすい方法で整理できる詳細なREを有効にする

マッチ機能

この関数は、オプションのフラグを使用して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/python3
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print ("matchObj.group() : ", matchObj.group())
   print ("matchObj.group(1) : ", matchObj.group(1))
   print ("matchObj.group(2) : ", matchObj.group(2))
else:
   print ("No match!!")

上記のコードを実行すると、次の結果が得られます。

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

検索機能

この関数は、オプションのフラグを使用して、文字列内で最初に出現する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/python3
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print ("searchObj.group() : ", searchObj.group())
   print ("searchObj.group(1) : ", searchObj.group(1))
   print ("searchObj.group(2) : ", searchObj.group(2))
else:
   print ("Nothing found!!")

上記のコードを実行すると、次の結果が得られます。

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

マッチングと検索

Pythonは、正規表現に基づいて2つの異なるプリミティブ操作を提供します。 match 文字列の先頭でのみ一致をチェックしますが、 search 文字列内の任意の場所で一致するかどうかをチェックします（これはPerlがデフォルトで行うことです）。

例

#!/usr/bin/python3
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print ("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print ("search --> searchObj.group() : ", searchObj.group())
else:
   print ("Nothing found!!")

上記のコードを実行すると、次の結果が得られます。

No match!!
search --> matchObj.group() :  dogs

検索と置換

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

構文

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

このメソッドは、文字列内のREパターンのすべてのオカレンスをreplに置き換え、maxが指定されていない限りすべてのオカレンスを置き換えます。このメソッドは、変更された文字列を返します。

例

#!/usr/bin/python3
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print ("Phone Num : ", num)

# Remove anything other than digits
num = re.sub(r'\D', "", phone)    
print ("Phone Num : ", num)

上記のコードを実行すると、次の結果が得られます。

Phone Num :  2004-959-559
Phone Num :  2004959559

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

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

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

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 Word - First CGI Program</title>')
print ('</head>')
print ('<body>')
print ('<h2>Hello Word! This is my first CGI program</h2>')
print ('</body>')
print ('</html>')

Note−スクリプトの最初の行は、Python実行可能ファイルへのパスである必要があります。Linuxでは＃！/ usr / bin / python3になります

ブラウザに次のURLを入力してください

http://localhost:8080/cgi-bin/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
SQLite

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

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

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

PythonにはSQLiteのサポートが組み込まれています。このセクションでは、MySQLを使用してすべての概念を学習します。MySQLの一般的なインターフェイスであるMySQLdbモジュールはPython3と互換性がありません。代わりに、PyMySQLモジュールを使用します。

PyMySQLとは何ですか？

PyMySQLは、PythonからMySQLデータベースサーバーに接続するためのインターフェイスです。Python Database API v2.0を実装し、純粋なPythonMySQLクライアントライブラリが含まれています。PyMySQLの目標は、MySQLdbのドロップイン代替品になることです。

PyMySQLをインストールするにはどうすればよいですか？

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

#!/usr/bin/python3

import pymysql

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

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

最後の安定版リリースはPyPIで利用可能であり、pip −を使用してインストールできます。

pip install pymysql

または（たとえば、pipが利用できない場合）、tarballをGitHubからダウンロードし、次のようにSetuptoolsでインストールできます。

$ # X.X is the desired pymysql version (e.g. 0.5 or 0.6).
$ curl -L https://github.com/PyMySQL/PyMySQL/tarball/pymysql-X.X | tar xz $ cd PyMySQL*
$ python setup.py install $ # The folder PyMySQL* can be safely removed now.

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

データベース接続

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

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

例

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

#!/usr/bin/python3

import pymysql

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

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

# execute SQL query using execute() method.
cursor.execute("SELECT VERSION()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print ("Database version : %s " % data)

# disconnect from server
db.close()

このスクリプトを実行すると、次の結果が生成されます。

Database version : 5.5.20-log

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

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

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

例

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

#!/usr/bin/python3

import pymysql

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

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

# Drop table if it already exist using execute() method.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

# Create table as per requirement
sql = """CREATE TABLE EMPLOYEE (
   FIRST_NAME  CHAR(20) NOT NULL,
   LAST_NAME  CHAR(20),
   AGE INT,  
   SEX CHAR(1),
   INCOME FLOAT )"""

cursor.execute(sql)

# disconnect from server
db.close()

INSERT操作

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

例

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

#!/usr/bin/python3

import pymysql

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

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

# Prepare SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
   LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

上記の例は、SQLクエリを動的に作成するために次のように記述できます-

#!/usr/bin/python3

import pymysql

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

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

# Prepare SQL query to INSERT a record into the database.
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
   LAST_NAME, AGE, SEX, INCOME) \
   VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
   ('Mac', 'Mohan', 20, 'M', 2000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

例

次のコードセグメントは、パラメータを直接渡すことができる別の実行形式です。

..................................
user_id = "test123"
password = "password"

con.execute('insert into Login values("%s", "%s")' % \
             (user_id, password))
..................................

READ操作

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

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

fetchone()−クエリ結果セットの次の行をフェッチします。結果セットは、カーソルオブジェクトを使用してテーブルをクエリしたときに返されるオブジェクトです。
fetchall()−結果セットのすべての行をフェッチします。一部の行が結果セットからすでに抽出されている場合は、結果セットから残りの行を取得します。
rowcount −これは読み取り専用属性であり、execute（）メソッドの影響を受けた行数を返します。

例

次の手順では、給与が1000を超えるEMPLOYEEテーブルのすべてのレコードをクエリします。

#!/usr/bin/python3

import pymysql

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

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

# Prepare SQL query to INSERT a record into the database.
sql = "SELECT * FROM EMPLOYEE \
      WHERE INCOME > '%d'" % (1000)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Fetch all the rows in a list of lists.
   results = cursor.fetchall()
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
      # Now print fetched result
      print ("fname = %s,lname = %s,age = %d,sex = %s,income = %d" % \
         (fname, lname, age, sex, income ))
except:
   print ("Error: unable to fetch data")

# disconnect from server
db.close()

出力

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

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

更新操作

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

次の手順では、SEXを次のように持つすべてのレコードを更新します。 'M'。ここでは、すべての男性の年齢を1年増やします。

例

#!/usr/bin/python3

import pymysql

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

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

# Prepare SQL query to UPDATE required records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
                          WHERE SEX = '%c'" % ('M')
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   db.commit()
except:
   # Rollback in case there is any error
   db.rollback()

# disconnect from server
db.close()

DELETE操作

データベースから一部のレコードを削除する場合は、DELETE操作が必要です。以下は、AGEが20を超えるEMPLOYEEからすべてのレコードを削除する手順です。

例

#!/usr/bin/python3

import pymysql

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

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

# Prepare SQL query to 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/python3           # This is server.py file
import socket                                         

# create a socket object
serversocket = socket.socket(
	        socket.AF_INET, socket.SOCK_STREAM) 

# get local machine name
host = socket.gethostname()                           

port = 9999                                           

# bind to the port
serversocket.bind((host, port))                                  

# queue up to 5 requests
serversocket.listen(5)                                           

while True:
   # establish a connection
   clientsocket,addr = serversocket.accept()      

   print("Got a connection from %s" % str(addr))
    
   msg = 'Thank you for connecting'+ "\r\n"
   clientsocket.send(msg.encode('ascii'))
   clientsocket.close()

シンプルなクライアント

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

ザ・ socket.connect(hosname, port )TCP接続が開き、ホスト名のポートを。ソケットを開いたら、他のIOオブジェクトと同じようにソケットから読み取ることができます。完了したら、ファイルを閉じるのと同じように、忘れずに閉じてください。

例

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

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

import socket

# create a socket object
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 

# get local machine name
host = socket.gethostname()                           

port = 9999

# connection to hostname on the port.
s.connect((host, port))                               

# Receive no more than 1024 bytes
msg = s.recv(1024)                                     

s.close()
print (msg.decode('ascii'))

次に、このserver.pyをバックグラウンドで実行してから、上記のclient.pyを実行して結果を確認します。

# Following would start a server in background.
$ python server.py & # Once server is started run client as follows: $ python client.py

出力

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

on server terminal
Got a connection from ('192.168.1.10', 3747)
On client terminal
Thank you for connecting

Pythonインターネットモジュール

Pythonネットワーク/インターネットプログラミングのいくつかの重要なモジュールのリストを以下に示します-

プロトコル	共通機能	ポート番号	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/python3

import smtplib

sender = '[email protected]'
receivers = ['[email protected]']

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

ここでは、ヘッダーを正しくフォーマットするように注意しながら、三重引用符を使用して基本的な電子メールをメッセージに配置しました。電子メールにはFrom、 To、および Subject 電子メールの本文から空白行で区切られたヘッダー。

メールを送信するには、smtpObjを使用してローカルマシンのSMTPサーバーに接続します。次に、sendmailメソッドを、メッセージ、差出人アドレス、および宛先アドレスとともにパラメーターとして使用します（差出人アドレスと宛先アドレスは電子メール自体の中にありますが、これらは常にメールのルーティングに使用されるとは限りません）。

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

mail = smtplib.SMTP('smtp.gmail.com', 587)

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

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

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

例

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

#!/usr/bin/python3

import smtplib

message = """From: From Person <[email protected]>
To: To Person <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP HTML e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)         
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

添付ファイルを電子メールで送信する

内容が混在するメールを送信するには、 Content-type へのヘッダー multipart/mixed。次に、テキストと添付ファイルのセクションを内で指定できますboundaries。

境界は、2つのハイフンで始まり、その後に一意の番号が続きます。これは、電子メールのメッセージ部分には表示できません。電子メールの最後のセクションを示す最後の境界も、2つのハイフンで終わる必要があります。

添付ファイルは、 pack("m") 送信前にbase64エンコーディングを使用する関数。

例

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

#!/usr/bin/python3

import smtplib
import base64

filename = "/tmp/test.txt"

# Read a file and encode it into base64 format
fo = open(filename, "rb")
filecontent = fo.read()
encodedcontent = base64.b64encode(filecontent)  # base64

sender = '[email protected]'
reciever = '[email protected]'

marker = "AUNIQUEMARKER"

body ="""
This is a test email to send an attachement.
"""
# Define the main headers.
part1 = """From: From Person <[email protected]>
To: To Person <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=%s
--%s
""" % (marker, marker)

# Define the message action
part2 = """Content-Type: text/plain
Content-Transfer-Encoding:8bit

%s
--%s
""" % (body,marker)

# Define the attachment section
part3 = """Content-Type: multipart/mixed; name=\"%s\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename=%s

%s
--%s--
""" %(filename, filename, encodedcontent, marker)
message = part1 + part2 + part3

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, reciever, message)
   print "Successfully sent email"
except Exception:
   print ("Error: unable to send email")

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

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

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

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

スレッドには2つの異なる種類があります-

カーネルスレッド
ユーザースレッド

カーネルスレッドはオペレーティングシステムの一部ですが、ユーザースペーススレッドはカーネルに実装されていません。

Python3でのスレッドの使用をサポートする2つのモジュールがあります-

_thread
threading

スレッドモジュールはかなり長い間「非推奨」になっています。代わりにスレッドモジュールを使用することをお勧めします。したがって、Python 3では、モジュール「スレッド」は使用できなくなりました。ただし、Python3での下位互換性のために、名前が「_thread」に変更されました。

新しいスレッドの開始

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

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

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

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

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

例

#!/usr/bin/python3

import _thread
import time

# Define a function for the thread
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print ("%s: %s" % ( threadName, time.ctime(time.time()) ))

# Create two threads as follows
try:
   _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print ("Error: unable to start thread")

while 1:
   pass

出力

上記のコードを実行すると、次の結果が得られます。

Thread-1: Fri Feb 19 09:41:39 2016
Thread-2: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:41 2016
Thread-1: Fri Feb 19 09:41:43 2016
Thread-2: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:45 2016
Thread-1: Fri Feb 19 09:41:47 2016
Thread-2: Fri Feb 19 09:41:49 2016
Thread-2: Fri Feb 19 09:41:53 2016

プログラムは無限ループになります。停止するには、ctrl-cを押す必要があります

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

スレッドモジュール

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

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print ("Starting " + self.name)
      print_time(self.name, self.counter, 5)
      print ("Exiting " + self.name)

def print_time(threadName, delay, counter):
   while counter:
      if exitFlag:
         threadName.exit()
      time.sleep(delay)
      print ("%s: %s" % (threadName, time.ctime(time.time())))
      counter -= 1

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("Exiting Main Thread")

結果

上記のプログラムを実行すると、次の結果が生成されます-

Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:00:21 2016
Thread-2: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:22 2016
Thread-1: Fri Feb 19 10:00:23 2016
Thread-2: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:24 2016
Thread-1: Fri Feb 19 10:00:25 2016
Exiting Thread-1
Thread-2: Fri Feb 19 10:00:26 2016
Thread-2: Fri Feb 19 10:00:28 2016
Thread-2: Fri Feb 19 10:00:30 2016
Exiting Thread-2
Exiting Main Thread

スレッドの同期

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

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

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

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

例

#!/usr/bin/python3

import threading
import time

class myThread (threading.Thread):
   def __init__(self, threadID, name, counter):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.counter = counter
   def run(self):
      print ("Starting " + self.name)
      # Get lock to synchronize threads
      threadLock.acquire()
      print_time(self.name, self.counter, 3)
      # Free lock to release next thread
      threadLock.release()

def print_time(threadName, delay, counter):
   while counter:
      time.sleep(delay)
      print ("%s: %s" % (threadName, time.ctime(time.time())))
      counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
   t.join()
print ("Exiting Main Thread")

出力

上記のコードを実行すると、次の結果が得られます。

Starting Thread-1
Starting Thread-2
Thread-1: Fri Feb 19 10:04:14 2016
Thread-1: Fri Feb 19 10:04:15 2016
Thread-1: Fri Feb 19 10:04:16 2016
Thread-2: Fri Feb 19 10:04:18 2016
Thread-2: Fri Feb 19 10:04:20 2016
Thread-2: Fri Feb 19 10:04:22 2016
Exiting Main Thread

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

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

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

例

#!/usr/bin/python3

import queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
   def __init__(self, threadID, name, q):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.name = name
      self.q = q
   def run(self):
      print ("Starting " + self.name)
      process_data(self.name, self.q)
      print ("Exiting " + self.name)

def process_data(threadName, q):
   while not exitFlag:
      queueLock.acquire()
      if not workQueue.empty():
         data = q.get()
         queueLock.release()
         print ("%s processing %s" % (threadName, data))
      else:
         queueLock.release()
         time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

# Create new threads
for tName in threadList:
   thread = myThread(threadID, tName, workQueue)
   thread.start()
   threads.append(thread)
   threadID += 1

# Fill the queue
queueLock.acquire()
for word in nameList:
   workQueue.put(word)
queueLock.release()

# Wait for queue to empty
while not workQueue.empty():
   pass

# Notify threads it's time to exit
exitFlag = 1

# Wait for all threads to complete
for t in threads:
   t.join()
print ("Exiting Main Thread")

出力

上記のコードを実行すると、次の結果が得られます。

Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

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

大きなファイルを処理する場合、SAXは明らかにDOMほど高速に情報を処理できません。一方、DOMを排他的に使用すると、特に多くの小さなファイルで使用されている場合、リソースが実際に停止する可能性があります。

SAXは読み取り専用ですが、DOMではXMLファイルへの変更が許可されています。これらの2つの異なるAPIは文字通り互いに補完し合うため、大規模なプロジェクトで両方を使用できない理由はありません。

すべてのXMLコード例について、単純なXMLファイルmovies.xmlを入力として使用しましょう-

<collection shelf = "New Arrivals">
<movie title = "Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title = "Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title = "Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title = "Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

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

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print ("*****Movie*****")
         title = attributes["title"]
         print ("Title:", title)

   # Call when an elements ends
   def endElement(self, tag):
      if self.CurrentData == "type":
         print ("Type:", self.type)
      elif self.CurrentData == "format":
         print ("Format:", self.format)
      elif self.CurrentData == "year":
         print ("Year:", self.year)
      elif self.CurrentData == "rating":
         print ("Rating:", self.rating)
      elif self.CurrentData == "stars":
         print ("Stars:", self.stars)
      elif self.CurrentData == "description":
         print ("Description:", self.description)
      self.CurrentData = ""

   # Call when a character is read
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # create an XMLReader
   parser = xml.sax.make_parser()
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

出力

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

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

SAX APIドキュメントの詳細については、標準の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/python3

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print ("Root element : %s" % collection.getAttribute("shelf"))

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print ("*****Movie*****")
   if movie.hasAttribute("title"):
      print ("Title: %s" % movie.getAttribute("title"))

   type = movie.getElementsByTagName('type')[0]
   print ("Type: %s" % type.childNodes[0].data)
   format = movie.getElementsByTagName('format')[0]
   print ("Format: %s" % format.childNodes[0].data)
   rating = movie.getElementsByTagName('rating')[0]
   print ("Rating: %s" % rating.childNodes[0].data)
   description = movie.getElementsByTagName('description')[0]
   print ("Description: %s" % description.childNodes[0].data)

出力

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

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

DOM APIドキュメントの詳細については、標準のPython DOMAPIを参照してください。

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

Tkinter− Tkinterは、Pythonに同梱されているTkGUIツールキットへのPythonインターフェースです。この章では、このオプションについて説明します。
wxPython−これはwxWidgetsGUIツールキット用のオープンソースのPythonインターフェースです。WxPythonの完全なチュートリアルはここにあります。
PyQt-これは、人気のあるクロスプラットフォームのQtGUIライブラリ用のPythonインターフェイスでもあります。TutorialsPointには、PyQtに関する非常に優れたチュートリアルがあります。
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/python3

import tkinter # note that module name has changed from Tkinter in Python 2 to tkinter in Python 3
top = tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()

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

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のジオメトリマネージャークラスを公開しています。

pack（）メソッド-このジオメトリマネージャーは、ウィジェットを親ウィジェットに配置する前に、ウィジェットをブロックに編成します。
grid（）メソッド-このジオメトリマネージャーは、親ウィジェットのテーブルのような構造でウィジェットを編成します。
place（）メソッド-このジオメトリマネージャーは、ウィジェットを親ウィジェットの特定の位置に配置することでウィジェットを整理します。

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

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

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

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

Unixマシンでは、これには通常、などの開発者固有のパッケージをインストールする必要があります。
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.pyasと呼ばれるセットアップスクリプトを介してビルドおよびインストールされます。

上記のモジュールでは、次の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/python3
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}のような辞書を返します。

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

シニア番号	機能と説明
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）呼び出し元のスレッドをsecs秒間中断します。
9	time.strftime（fmt [、tupletime]）現地時間のタイムタプルとして表されるインスタントを受け入れ、文字列fmtで指定されたインスタントを表す文字列を返します。
10	time.strptime（str、fmt = '％a％b％d％H：％M：％S％Y'）フォーマット文字列fmtに従ってstrを解析し、タイムタプル形式でインスタントを返します。
11	time.time（）現在の時刻、エポックからの浮動小数点秒数を返します。
12	time.tzset（）ライブラリルーチンで使用される時間変換ルールをリセットします。環境変数TZは、これがどのように行われるかを指定します。

シニア番号	メソッド、説明、サンプルコール
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）