Pythonを書き始める前に見るべきTips

Pythonを使ってこの方さまざまな点につまずいたが、ここではそんなトラップを回避して快適なPython Lifeを送っていただくべく、書き始める前に知っておけばよかったというTipsをまとめておく。

## Python2系と3系について
Pythonには2系と3系があり、3系では後方互換性に影響のある変更が入れられている。つまり、Python3のコードはPython2では動かないことがある(逆もしかり)。

Python3ではPython2における様々な点が改善されており、今から使うなら最新版のPython3で行うのが基本だ(下記でも、Python3で改善されるものは明記するようにした)。何より、Python2は[2020年1月1日をもってサポートが終了した](http://legacy.python.org/dev/peps/pep-0373/)。よって今からPython2を使う理由はない。未だにPython2を使う者は、[小学生にもディスられる](https://togetter.com/li/1027888)。

しかし、世の中にはまだPython3に対応していないパッケージもあり、自分のプロジェクトでそうしたパッケージに当たるかどうかが運命の分かれ道になる。対応状況については、[こちら](https://python3wos.appspot.com/)から一覧で確認することができる。ただ、ほとんどのパッケージは対応済みかPython3で動かすすべがあると思ってよいと思うし[2から3への自動変換もある](http://docs.python.jp/2/library/2to3.html)。逆にPython3に対応していないならメンテナンス状況を疑うべき状況に来ているともいえる。Google App Engineについても[第二世代でとうとうPython3に対応した](https://cloud.google.com/appengine/docs/standard/appengine-generation)。人工知能の先端的研究機関であるOpenAIでも[Python3へ移行している](https://github.com/openai/pixel-cnn)ので、「機械学習周りはまだ～」という者は少なくとも先端でない人間なので、言うことを当てにする必要はない。

## Pythonのセットアップ

Pythonの開発をする場合Python本体以外にpip、virtualenvのインストールがほぼ必須になるので、各環境でのPython・pip・virtualenvのセットアップ方法をまとめておく。

### 機械学習を行いたい場合

Pythonを選択する理由として機械学習を行ってみたい、というのが多くの理由としてあると思うので、そのための方法をまず先に紹介しておく。機械学習のための環境を構築するには、Mac/Linux/Windowsの何れかに関わらずMinicondaの利用を推奨する。

[Miniconda](https://conda.io/miniconda.html)

インストール方法は上記のページの通りとなる。Minicondaはアプリケーションごとの環境(仮想環境)を作成する機能の他、機械学習関係のパッケージのインストールが行いやすくなっている。また、GPUに必要な[cuda](https://anaconda.org/pytorch/repo)や、Windowsのビルド環境である[mingw](https://anaconda.org/anaconda/mingw)などもインストールが可能であり、単純なパッケージ以外のツールの導入も楽になる。TensorFlowについては、condaでインストールすることでGPU周りのツールもインストールしてくれる他、CPU版の場合高速に動作する([詳細](https://www.anaconda.com/blog/developer-blog/tensorflow-in-anaconda/))。

scikit-learnをJupyter Notebook上で行うというような一般的な機械学習の環境の構築は、Minicondaインストール後以下のようなコマンドで作成できる。

```
conda create -n ml_env numpy scipy scikit-learn matplotlib jupyter
activate ml_env
```

`conda create`で`ml_env`という環境を作成し、`activate`でそれを有効化している。`conda`コマンドの詳しい利用方法については、[こちら](https://qiita.com/icoxfog417/items/02a80b93b5f1e95f2795)を参考されたし(Windows/Powershellの場合は起動しない。詳細は[Windowsのセクション](https://qiita.com/icoxfog417/items/e8f97a6acad07903b5b0#windows%E3%81%AE%E5%A0%B4%E5%90%88)参考)。

Minicondaの環境は`Dockerfile`でも提供されており、これを`FROM continuumio/miniconda3`などで継承して利用することで簡単にコンテナを作成することができる。

* Python2用：[docker-images/miniconda](https://github.com/ContinuumIO/docker-images/tree/master/miniconda)
* Python3用：[docker-images/miniconda3](https://github.com/ContinuumIO/docker-images/tree/master/miniconda3)

Dockerコンテナで機械学習環境を共有したい場合、またHerokuなどのPaaS環境へのデプロイを考えている場合はDockerの使用を検討することをお勧めする([HerokuはContainer Registryの機能でdocker pushに対応している](https://devcenter.heroku.com/articles/container-registry-and-runtime))。

なお、以下2点の理由によりAnacondaは機械学習の環境として推奨しない。

* サイズが重すぎる
  * Anacondaはインストールしただけで2~3Gは持っていかれるが、Minicondaはその1/4以下で同等の環境を作成できる
* 依存関係がわからなくなる
  * Anacondaはいわゆる全部入りの環境なので、アプリケーションの開発を行った際どのライブラリに依存しているのかわからなくなる。これは、デプロイなどを行う際問題となる

なお、**Minicondaでも定期的に`conda clean --all`で使っていないパッケージを削除しないと軽く数G持っていかれるので注意が必要**。これは、condaが一度ダウンロードしたことがあるパッケージをキャッシュとして保管するためである。今は使っていない古いパッケージであっても消していない限り残るので、これを削除するのが吉。

### Pythonの導入

#### Mac/Linuxの場合

システムデフォルトでPythonが入っているが、開発したいバージョンとは一致しないこともある。そのため、[pyenv](https://github.com/yyuu/pyenv#homebrew-on-mac-os-x)を利用してプロジェクトごとに利用するPythonのバージョンを切り替えられるようにするのが良い。
ただ、前述の通りMinicondaを利用する場合はこちらでPythonのバージョン管理が可能なため、あえてpyenvを導入する必要はない。さらに言えば、仮想環境の有効化(`activate`)を行う際にコマンドのバッティングが発生しシェルがハングするためMinicondaを利用する場合はpyenvを導入しないほうが良い。

* pyenvのインストール
 * Mac: [【Mac】Pythonのインストール+pyenvの使い方について](http://www.task-notes.com/entry/20141215/1418612400)
 * Linux: [PyenvによるPython3.x環境構築(CentOS, Ubuntu)](http://qiita.com/akito1986/items/be5dcd1a502aaf22010b)
* Pythonのインストール: `pyenv install x.x.x` で使用するPythonをインストール。その後、`pyenv global x.x.x`で使うPythonを設定

各プロジェクトで使用するPythonは、`pyenv local x.x.x`で設定する。
なお、pyenvで新しいPython環境をインストールした後は[`pyenv rehash`が必要](https://github.com/yyuu/pyenv#basic-github-checkout)。それでもインストールした環境が見つからない場合は、ターミナルを再起動してみる。

#### Windowsの場合

普通にインストールしてもよいが、[Miniconda](http://conda.pydata.org/miniconda.html)をお勧める。

なお、2018時点では[PowerShellではまだ`activate`が起動しない](https://github.com/conda/conda/issues/626)ので注意が必要。いちいち`cmd`に切り替えるのが面倒な場合は、`pscondaenvs`を導入すれば使うことができる(以下は、グローバルの環境(`root`)に導入する場合)。

```
conda install -n root -c pscondaenvs pscondaenvs
```

### パッケージ管理(pip)/仮想環境構築ライブラリ(virtualenv)の導入

パッケージ管理はライブラリのインストールに、仮想環境はプロジェクトごとにPythonのバージョンや使用するライブラリを切り分けるために導入する。

`pip`はPython3.4から標準搭載されているため、現状では別途インストールを行う必要はない。古いPythonを使用する場合は、 [get_pip.py](https://pip.pypa.io/en/latest/installing.html#install-pip)でインストールを行う。

`virtualenv`は、`pip install virtualenv`で導入可能である。

ただ、公式ではpip/virtualenvの機能を内包した[Pipenv](https://pipenv.readthedocs.io/en/latest/)の利用を推奨している。
Pipenvでは、Node.jsにおけるnpmのように、インストールと同時に依存ライブラリを書き出す、開発用/本番用のインストールライブラリを切り分ける、といったことが容易に可能となっている。

## Pythonでの開発の流れ

Pythonの開発はだいたい以下の段取りで行う。

1. プロジェクト用の仮想環境を作成する  
Pythonではプロジェクトの稼働に必要なライブラリはグローバルにインストールせず、個別の仮想環境にインストールするのが通例で、そのためのツールがvirtualenvやcondaなどになる
2. 仮想環境に必要なモジュールをインストールする  
仮想環境を有効化した後、pipなどを使用しプロジェクトに必要なライブラリをインストールする。インストールしたライブラリはファイルに書き出し、他の人がインストールできるようにする。逆に他の人が作成したツールなどを使う際は、ファイルに書き出された依存ライブラリをインストールする
3. Pythonプログラムの作成、実行を行う

コマンドに書き直すと以下のような形となる。新式のpipenvを使用する場合、従来のpip/virtualenvを使用する場合、condaを使う場合の3つを紹介する。

### pipenvを使用する場合

[`pipenv`](https://pipenv.readthedocs.io/en/latest/)では、明示的に仮想環境の作成を指示する必要がない。`pipenv install`でインストールを行えば勝手に仮想環境を作成しそこにインストールしてくれる。ただし、デフォルトではよくわからないパスに作成され、そのままでは統合開発環境などでコード保管の恩恵が受けにくい。

そのため、使用前には`PIPENV_VENV_IN_PROJECT=1`(もしくは`true`)を設定する方が良い。こうすることで、カレントフォルダの`.venv`に仮想環境が構築される。

```
# 1. プロジェクトのフォルダを作成
mkdir myproject 
cd myproject

# 2. pipenvで必要なライブラリをインストール

pipenv install xxxx

## 開発でしか使わないライブラリ(testなどに使うライブラリなど)には`-dev`をつける

pipenv install --dev xxxx

## pipenvでインストールしたライブラリは自動的にPipfile.lockに書き込まれる。これを読み込みインストールする場合は、単にpipenv installを実行する

pipenv install

# 3. 実行する
pipenv run python xxx.py

## shellを起動したい場合は、pipenv shellとする

pipenv shell

# 作成した環境を削除する際は以下

pipenv --rm

```

### pip/virtualenvを使用する場合

```
# 1. プロジェクトのフォルダを作成
mkdir myproject 
cd myproject

# 2. 仮想環境の作成 venvはフォルダ名でここにプロジェクト用の環境が用意される
virtualenv venv 

# 3. 仮想環境を有効化し、pipで必要なモジュールをインストール
# Windowsの場合、venv/Scripts/activate.bat なお、Gitのシェルを利用すると同じようにsourceでできる
# 仮想環境のactivateを行わないと、グローバルにインストールされるので注意 なお、無効化はdeactivate

source venv/bin/activate

pip install xxxx

# pip freezeで作成した一覧(requirements.txt)からインストールする場合は以下
pip install -r requirements.txt

# 4.実行する
python xxx.py
```

### condaを使用する場合

```
# 1. 仮想環境を作成(virtualenv的なもの)
conda create -n my_env numpy scipy

## 仮想環境の一覧を表示
conda info -e

# 2. 仮想環境を有効化
activate my_env # Windows
source activate my_env # Max/Linux

## 仮想環境に追加でインストール(バージョンを指定する場合conda install scipy=0.12.0など)
conda install scikit-learn

## condaで取得できないものについて、pipでインストール(仮想環境にpipを入れて対応)
conda install pip
pip install Flask

## インストールしたパッケージのアップデート(conda自身はconda update conda)
conda update numpy

# 3. condaで構築した環境を書き出し/読み込み
conda env export > environment.yml
conda env create -f environment.yml

# 4. 仮想環境無効化
deactivate # Windows
source deactivate # Max/Linux

```

詳細は[こちら](http://qiita.com/icoxfog417/items/02a80b93b5f1e95f2795)参照。

### Gitによる管理について

バージョン管理の対象としてはずしておくべきなのが、上記の仮想環境のフォルダ(venvなど)と、`.pyc`ファイルになる。
`.pyc`ファイルは実行を高速化するためのファイルで、一旦実行すると一ファイルにつき一つできていく。これをバージョン管理に入れてしまうとファイルが二倍になってしまうので、これははずしておく必要がある(-Bオプションをつけるか、環境変数 PYTHONDONTWRITEBYTECODEを設定することで生成しないようにすることもできる[(参照)](http://docs.python.jp/2/using/cmdline.html#envvar-PYTHONDONTWRITEBYTECODE))。
その他無視すべきファイルについては、[Pythonの.gitignore](https://github.com/github/gitignore/blob/master/Python.gitignore)等を参考にしてください。

### Tips

なお、ライブラリによっては`pip install`で素直に入らないものも存在する。これはWindowsにおいて顕著である。`conda install`で回避可能な場合が多いが、それでも解決しない場合以下の対応を行う。

1. [Unofficial Windows Binaries for Python Extension Packages](http://www.lfd.uci.edu/~gohlke/pythonlibs/)で該当するパッケージを見つけ、`pip install <file_path>` でインストールを行う(余談だが、wheelを使うことで依存ライブラリをコンパイルした状態でリポジトリに含めることができる。これにより配布・デプロイする際相手先の環境でpip installできないという事態を防ぐことができる。詳細は[ドキュメント参考](https://pip.pypa.io/en/latest/reference/pip_wheel.html#usage))。
2. exe形式のファイルが提供されている場合は、[easy_installを頑張って入れて](http://qiita.com/icoxfog417/items/c91ba9555a247e9e8979#easy_install%E3%81%AE%E3%82%A4%E3%83%B3%E3%82%B9%E3%83%88%E3%83%BC%E3%83%AB)インストールする。
3. コンパイルするしかない!という場合は・・・まずはVisual Studioをインストールしよう。その後、以下を参考に環境変数を設定をする。
 * [Python で “error: Unable to find vcvarsall.bat” が出た場合。Add Star](http://mimumimu.net/blog/2014/06/01/python-%E3%81%A7-error-unable-to-find-vcvarsall-bat-%E3%81%8C%E5%87%BA%E3%81%9F%E5%A0%B4%E5%90%88%E3%80%82/)
 * [「Unable to find vcvarsall.bat」の対処法](http://www.regentechlog.com/2014/04/13/build-python-package-on-windows/)
 * MinGWやCygwinが必要になるケースもあるが、MinGWについては実はcondaでconda install mingwでインストールできるので、これで対応可能な場合もある。ただ、そんな事態の場合は`gfortran`とかがどのみち必要なので、他の環境の整備も考えれば素直にインストールしたほうがいいかもしれない。
4. 最終手段として、Windows Subsystem for Linuxを使いLinux環境で開発を行う。セットアップ方法については、[こちら](http://qiita.com/Aruneko/items/c79810b0b015bebf30bb)を参考されたし。この最終手段が取れるようになったことにより、Windowsで「できない」という状況は事実上なくなった。

これでPythonの開発環境は整ったので、以下からは本題であるPythonで開発をする際に気を付けるべき点を挙げていく。

## ファイルのエンコードを宣言する必要がある(2のみ)

各ファイルの先頭に以下を付けておかないと、日本語などは文字化けるので注意。[こちら](http://nekoya.github.io/pages/python_coding/)で言及されているように、ファイルの先頭に常につけるようにした方がよいだろう。

```py
# -*- coding: utf-8 -*-
```

なお、Python3ではデフォルトのエンコードがUTF-8となっているのでこの対応は不要となっている([PEP 3120 -- Using UTF-8 as the default source encoding](https://www.python.org/dev/peps/pep-3120/))。

幾つか下記でも述べるがPython2/3両対応が想定される場合、そうでなくてもPython3の恩恵(特にunicode統一)を受けたい場合は以下のimportもしておくと良い([こちら](http://methane.hatenablog.jp/entry/2014/01/18/Python_2/3_%E4%B8%A1%E5%AF%BE%E5%BF%9C%E3%81%AE%E3%81%9F%E3%82%81%E3%81%AB_%60unicode_literals%60_%E3%82%92%E4%BD%BF%E3%81%86%E3%81%B9%E3%81%8D%E3%81%8B)ご参考)。

```py
from __future__ import division, print_function, absolute_import, unicode_literals
```

## コーディングガイドがあり統合開発環境でチェックできる
Pythonには公式に定められたコーディングガイド(PEP8)があり([原文](http://legacy.python.org/dev/peps/pep-0008/)/[日本語訳](http://pep8-ja.readthedocs.io/ja/latest/))、多くの統合開発環境ではこれを利用したチェックが可能になっている。

改行が多すぎる、空白文字の有無、といった点など結構細かくチェックでき、自分でも見落としていた点を修正できるので便利。逆に、最初から入れていないと後で修正が大変なので、環境セットアップ時に入れておこう。

その名の通りPEP8に適合しているかどうかをチェックする[pep8](https://pypi.python.org/pypi/pep8)というパッケージは、現在メンテナンスされておらず[pycodestyle](https://github.com/PyCQA/pycodestyle)となっているので注意が必要(この背景としては、"pep8"というパッケージ名が規約のことなのかツールのことなのか紛らわしいということで、[名称が変更されが提案されたため](https://github.com/PyCQA/pycodestyle/issues/466))。

pep8と合わせ、論理的なチェック(不要なインポートや未使用変数など)のみにとどめたい場合は、pep8のチェックを行うpycodestyleと論理チェックを行うpyflakesがパックになった[flake8](http://flake8.pycqa.org/en/latest/)を推奨する。
[Pylint](https://www.pylint.org/)は多様なチェックが可能だが、煩わしく感じられるシーンも多く適切なレベルに設定するにはそれなりコストを払う必要がある。

そのため、まずはflake8、その後コーディング規約をより高度にする必要に迫られた場合にPylintへ移行するというパスを推奨したい。


## ユニットテストフレームワークが標準搭載
Pythonには`unittest`が[標準搭載されている](http://docs.python.jp/2/library/unittest.html)ため、単体テストをするためにパッケージを追加する必要はない。

`unittest2`はあたかも新式フレームワークのように見えるが、これは古いバージョンで新しいバージョン用の単体テストフレームワークを利用するためのものなので、基本的に導入する必要はない(余談だがこの数字を振ったパッケージ名はやめてほしいと思う。urllib2とか)。

## 文字列には通常の文字列とユニコード文字列がある(2のみ)
Pythonでは通常の文字列の`str`とユニコード文字列を扱う`unicode`が分かれている。

```py
str = "abc" # An ordinary string
uni_str = u"abc" # A Unicode string
```

内部的にはstrのままであまり問題ないが、Webアプリケーションなど外部からの入力/外部への出力が絡む場合、unicodeで統一しておいた方がよい(フレームワークを利用する場合は、どちらで入ってくるか、どちらで値を渡すべきかを押さえておく必要がある)。
なお、Python3ではunicodeに統一される。また、Python2でも`from __future__ import unicode_literals`を使うことで`unicode`に統一できる。


## 割り算の結果がfloat型にならない(2のみ)
Python2系では1/3といった整数同士の割り算の結果がfloat型にならない。

```py
>>> 1/3
0
>>> 3/2
1
```

これが、Python3では解消する(上記の例では、0.333・・・、1.5という風に普通の算術演算結果となる)。
Python2系でもPython3と同じようにしたい、という場合は以下のimportを先頭で行うことで解消できる。

```
from __future__ import division
```

なお、除算では`//`という符号も存在する。これは一見商を出すための演算子と思いきや、そうではない。`//`による演算は、厳密には「計算結果を超えない最大の整数値」になる。
例えば3を2で割った場合、1.5となり、これを超えない最大の整数は1になる。これは商と等しく問題ないのだが、問題は値が負の場合。

```py
>>> -3 / 2
-2
```

符号がマイナスになっただけで結果が変わっている。何これ？と思うかもしれないが、マイナスの場合は-1.5を超えない最大の整数は`-2`になる、とそういうことになっており、バグではなく仕様である。そして、この仕様はPython3でも同様である。
よって、安全に商を計算したい場合は、結果がfloatになるよう計算し小数点以下を切り捨てる方が良い。Python3であれば、これは単純に`/`で計算した結果を切り捨てればよい。

なお、`divmod`という商と余りを同時に計算してくれる組み込み関数があるが、この関数における「商」は`//`の演算結果と同様なので注意が必要(ドキュメントで「商」としている以上、これはさすがにバグと言っていい気もするが・・・)。

## 四捨五入の仕様が銀行丸め(3より)

Pythonでの四捨五入にあたる`round`処理は、銀行丸めとなっている(最近接偶数への丸め、JIS丸め、ISO丸めとも呼ばれる)。具体的には、小数点以下が「0.5」となる場合偶数に近い方に寄せられる。これは、常に0.5をプラスに切り上げていると丸め前後の集計では(切り上げた)丸め後の集計の方が値が大きくなってしまう=偏りがでてしまうことから行われる処理になっている(詳細はWikipediaの[端数処理](https://ja.wikipedia.org/wiki/%E7%AB%AF%E6%95%B0%E5%87%A6%E7%90%86)参照)。

```py
>>> round(3 / 2)
2
>>> round(1 / 2)
0
```

`1 / 2 = 0.5`なので1じゃないのか、と思うがこれは算術丸めの話で、銀行丸めの場合は前述の通り「最も0.5に近い偶数」、すなわち0にまるめられる。なお、**Python2では算術丸めなので注意が必要**。

Python以外に銀行丸めを採用している言語としては、C#などがある(詳細は[こちら](https://qiita.com/nekonenene/items/05b85048feb05a6bb9ee#%E4%B8%80%E8%A6%A7%E8%A1%A8)参照)。

## 新スタイルクラスと旧スタイルクラスがある(2のみ)
良く紹介されている下記のクラス宣言では、旧スタイルクラスになる。

```py
class MyClass():
    pass
```

旧スタイルクラスと何が違うか？とはいろいろあるが、少なくとも今旧スタイルクラスで作成することは何のメリットもないということだ。
旧スタイルクラスでは親クラスを呼び出す`super`が機能しないので何のための継承かわからなくなる。

そのため、クラスは以下のように宣言する。

```py
class MyClass(object):
    pass
```

`object`を継承するということだ。
なお、Python3からはデフォルトで新スタイルクラスになり[旧スタイルクラスは削除される](http://docs.python.jp/2/reference/datamodel.html#newstyle)。

また、Python3では親クラスの呼び出し処理も簡易化される。Python2では`super(子クラス名, self).parent_method()`といった煩雑な呼び出し方法だったが、Python3では普通に`super().parent_method()`で呼び出せるようになる。


## 抽象クラス/インタフェースがない
継承は可能だが、下位クラスに実装を強制するような仕組みがない。
ただ、Python2.6からはabcが標準で追加され、疑似的に抽象クラスを実装できるようになった(abcとはabstract base classの略)。

* [抽象基底クラス(Python2)](http://docs.python.jp/2/library/abc.html)
* [抽象基底クラス(Python3)](http://docs.python.jp/3/library/abc.html)

```py
from abc import ABCMeta

class MyABC:
    __metaclass__ = ABCMeta
    
    def describe(self):
        print("I'm abc")
    
    @abstractmethod
    def must_implements(self):
        pass
```

Python3ではクラスの作成時に`metaclass`を使用できるようになったので、よりシンプルに書ける。

```py3
from abc import ABCMeta

class MyABC(metaclass=ABCMeta):
    ...
```

また、`register`を使うことであるクラスを自分の配下(サブクラス)に登録できる。ただ、単に「そう振る舞っているように見せる」だけなので、以下例でも実際にtupleがMyABCの継承クラスになっているわけではなく、現にMyABCで実装されているメソッドも使用することができない。

```py
MyABC.register(tuple)

assert issubclass(tuple, MyABC)
assert isinstance((), MyABC)

().describe()  # Attribute Error

```

`isinstance`でTrueになっているにもかかわらず、メソッドでAttribute Errorが出るのは正直混乱をきたす気がするので、利用シーンはあまりイメージできない。普通に継承したほうがよいと思う。
もちろん、普通にクラスを宣言して実装が強制されるメソッドは親クラスで例外をraiseするという手もある。

## 多重継承が可能
Pythonは数少ない多重継承をサポートしている言語になる。

```py
class MultiInheritance(Base1, Base2, Base3):
...
```

解決は左から順に行われ、上記では自分自身になければBase1、その次にBase2・・・と探索が行われる。
superは、普通に呼んだ場合一番左のクラスになる。

上述の通りPythonにはインタフェースがないため、その代りに多重継承を利用することになる(あるいはModule/Mix-in的な利用)。多重継承はそれ以外の用途には使用しない方が良いと思う。
ただ、見た目は全員クラスになるのでインタフェース的に使用するものは`I`から始めるなどクラス名のルールを決めておくと良いだろう(あるいはInterface/Moduleといったクラスを作りそれを継承させるなど)。

## コンストラクタ(と思われるもの)が2つある
Pythonには`__new__`と`__init__`という、どちらともコンストラクタなんじゃないの？と見える関数が2つある。
基本的には`__init__`を利用する。
ただ、引数の`self`を見ればわかるとおり`__init__`は「インスタンスが作成された後の初期化処理」であり、厳密にはコンストラクタではない。`__new__`は`__init__`で初期化するためのインスタンスを返却する処理になる。やろうと思えば自分のクラス以外のインスタンスを返却したりもできるが、そのメリットはあんまりない。シングルトンの実装に使うぐらいか。

## クラスに隠し属性が存在する
Pythonのインスタンスには上述の`__init__`のように、アンダースコア2つで囲われている隠し属性が存在する(クラス定義/関数定義自体にも存在する)。
これらはメタ情報を格納したり基本的な操作の実行(属性に値をセットする/取り出す際の挙動など)に使われている。
詳細は[データモデル](http://docs.python.jp/3.5/reference/datamodel.html)に詳しいが、よく使う/役立ちそうなものは下記となる。

| 属性名 | 内容 |
|:-----------|:-----------|
|`__class__`|クラス定義。`__class__.__name__`でクラス名が取得可能|
|`__dict__`|全属性(メソッド含む)をディクショナリ化したもの|
|`__doc__`|クラスやメソッドの[docstring](https://www.python.org/dev/peps/pep-0257/#one-line-docstrings)を取得可能。使い方が分からないけどソースコードやAPIドキュメントを探すのが面倒、という時にさくっと見られる|


| メソッド名 | 内容 |
|:-----------|:-----------|
|`__getattr__`|属性アクセスを行い、対象の属性がなかった場合呼び出される|
|`__getattribute__`|属性アクセスを行う際、常に呼び出される|
|`__setattr__`|属性への代入時に呼び出される|
|`__delattr__`|属性の削除時に呼び出される(`del obj.xxx`)|
|`__getstate__`|[オブジェクトの直列化(pickle化)](http://docs.python.jp/2/library/pickle.html)を行う|
|`__setstate__`|直列化したオブジェクトから復元を行う|
|`__str__`|クラスを文字列化するためのメソッド(いわゆるtoString)|
|`__repr__`|インスタンスの表記を出力するためのメソッド(型や一部のメンバなどを表記)|

`__str__`とは`__repr__`は似ているが、`__str__`は人間が変数の内容を知るためのもの(Readable)、`__repr__`は意図した型の変数かどうかを確認するためのもの(Unambiguous)という使い分けがある([参考](https://stackoverflow.com/questions/1436703/difference-between-str-and-repr-in-python))。行列変数などで`__repr__`にshapeを含めるのは良い使い方で、意図した変数を受け取り処理が行われているかを確認できる。ログ・コンソールなどに出力する際に人間が読めるようにするために、`__str__`でインスタンスの状態をフォーマット出力するのは意図に沿っている。

`obj["xxx"]`といった文字列でなく、`obj.xxx`と属性でアクセスしたい場合が多々あるが、その場合に上記の`__getattr__`などが有効になる。以下、[soundcloud-pythonでの実装例](https://github.com/soundcloud/soundcloud-python/blob/ac799b01e6464fd3b7dc057d089d5cb7ac2bdf62/soundcloud/resource.py)(`__init__`で渡されているobjはWeb APIから取得したディクショナリ型オブジェクト)。

```py
class Resource(object):
    """Object wrapper for resources.

    Provides an object interface to resources returned by the Soundcloud API.
    """
    def __init__(self, obj):
        self.obj = obj

    def __getstate__(self):
        return self.obj.items()

    def __setstate__(self, items):
        if not hasattr(self, 'obj'):
            self.obj = {}
        for key, val in items:
            self.obj[key] = val

    def __getattr__(self, name):
        if name in self.obj:
            return self.obj.get(name)
        raise AttributeError

    def fields(self):
        return self.obj

    def keys(self):
        return self.obj.keys()

```

WebAPIのラッパーなど、相手のレスポンスによって動的に属性を変えたい場合などに利用できるテクニックになる。詳細な利用方法は[こちら](https://www.inkling.com/read/learning-python-mark-lutz-4th/chapter-37/--getattr---and---getattribute--)も詳しい。

なお、インスタンス/クラス定義等の属性は`inspect`モジュールで抽出することができる。

```py
>>> import inspect
>>> inspect.getmembers(some_instance)
```

## Enumがない(2のみ)
[Python3.4.1からは標準搭載](https://docs.python.org/3/library/enum.html)されるが、それまではEnumがない。
使いたい場合は、`pip install enum34`でenumをインストールして使用する。

```py
import enum


class Color(enum.Enum):
    Red = 10
    Blue = 20
    Yellow = 30

>>> Color.Red == Color.Red
True

>>> Color.Red == 10
False
# EnumはあくまでEnum型オブジェクトのためこれはFalse。これをTrueにするIntEnumもある

>>> Color.Red == Color(10)
True
#コンストラクタに値を渡すことで該当のEnumを作成可能

>>> Color.Red == Color["Red"]
True
#名前から作成する際は[]で名称を指定

>>> {Color.Red:"red", Color.Blue:"blue"}
{<Color.Blue: 20>: 'blue', <Color.Red: 10>: 'red'}
# リストのキーとしても使用可能
```

なお、各項目の文字列を定義したい場合、`__str__`と併用することも可能。ラベル表示などを行う際、その定義を分散させたくないときに役に立つ。

```py3
class Color(enum.Enum):
    Red = 10
    Blue = 20
    Yellow = 30
    
    def __str__(self):
        if self.value == Color.Red.value:
            return "赤"
        elif self.value == Color.Blue.value:
            return "青"
        elif self.value == Color.Yellow.value:
            return "青"
```

```py
>>> print(Color.Red)
赤
```

## PrivateやProtectedがない
ないが、Privateなものは先頭に`__`か`_`を付けるという慣習がある。継承クラスにだけ見せたいなど、いわゆるProtectedに相当する概念はない。
では、`__`と`_`は何が違うのか？これは外部から隠蔽される度合いが変わってくる。

```py
class Test(object):
    def __init__(self):
        self.__a = 'a' # two underscores
        self._b = 'b' # one underscore

>>> t = Test()
>>> t._b
'b'

>>> t.__a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Test' object has no attribute '__a'
t.__a isn't found because it no longer exists due to namemangling

>>> t._Test__a
'a'
```

上記のように、アンダースコア一つの場合は一応通常通りアクセス可能だが(PEPでチェックしていると警告を出してくれる)、アンダースコアを二つ付けた場合は`_Test__a`としないとアクセスできない、というようによりPrivate的な形(普通は見えない)にしてくれる。

＜参考＞
[The meaning of a single- and a double-underscore before an object name in Python](
http://stackoverflow.com/questions/1301346/the-meaning-of-a-single-and-a-double-underscore-before-an-object-name-in-python)
[Difference between _, __ and __xx__ in Python](http://igorsobreira.com/2010/09/16/difference-between-one-underline-and-two-underlines-in-python.html)

## const/finalがない
Pythonでは定数を定義することができない。
ただ、後述するタプルは変更不可能なリストとなるので、これを利用すれば疑似的に定数を作成することは可能(変更不可なリストがあるくらいならconstがあっていい気もするが・・・)。

ここはPEP8では定数は全大文字でアンダースコアでつなぐべしとしているが、これに対するチェックはない。

## メソッドの第一引数が予約されている
※ここではメソッド=クラス内の関数、としています。通常の関数にこの制約はありません。
メソッドの最初の引数は、普通のメンバメソッドは`self`、クラスメソッドの場合`cls`で予約されている(引数名はじつは何でもよいが、慣例として`self`と`cls`が使用されている)。

```py
class Test(object):
    def __init__():
        pass

    def get_num(self):
        return 1

    def add_num(self, num):
        return self.get_num() + num
    
    @classmethod
    def test_print(cls):
        print "test"

```

上記の`get_num`は明らかに引数一つとっているように見えるが、これは実質的には引数なしのメソッドである。
そして、同クラス内のメンバ関数は`self.get_num()`となっているようにこの暗黙の第一引数である`self`や`cls`を利用して呼び出しを行う。

## リストとタプル(+可変長の引数)
Pythonには、ざっくり言えば「変更できないリスト」であるタプルというオブジェクトが存在する。これらは宣言方法が異なる。

```py
v_list = [10, 20, 30] # list
v_tuple = (10, 20, 30) # tuple

v_list[1] = 11 # ok
v_tuple[1] = 11 # error! 'tuple' object does not support item assignment
```

タプルは、その特性上ディクショナリのキーになることも可能である。
リストとタプルは可変長の引数を扱う関数/メソッドにも深く関わっている。

```py
def out_with_tuple(a,b,*args):
    # a,b以降の引数はtupleにまとめられる
    print(a,b,args)

>>> out_with_tuple(1,2,3,4,5)
(1, 2, (3, 4, 5))

def out_with_dict(a,b,**args):
    print(a,b,args)

>>> out_with_dict(1,2,one=3,two=4,three=5)
(1, 2, {'three': 5, 'two': 4, 'one': 3})
```

`*`というとポインタと思ってしまいがちだが、これは任意個数の引数を表し`*`の場合タプル、`**`の場合ディクショナリにまとめられる(併用も可能)。

そして、呼び出し側で`*`,`**`使うと逆にリスト/タプルの値を展開して引数として渡すことができる。

```py
>>> def out(a,b):
...    print(a,b)

>>> out([1,2])  # 普通にリストを渡した場合、当然NG
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: out() takes exactly 2 arguments (1 given)


>>> out(*[1,2])
(1,2)  # *によって、リスト内の要素が展開され、out(1,2)と呼び出したのと同じになる

>>> out_with_dict(**{"a":1,"b":2})
(1, 2, {})  # 上記同様、**によってディクショナリで渡した引数が展開される
```

## デフォルト引数はimmutableである必要がある
メソッドや関数のデフォルト引数として与える値は、immutableである必要がある。大体はそうなので問題はないが、空の配列はmutableに該当するので注意する必要がある。

```py
>>> class ArrayDefault():
>>>    def __init__(self, array=[]):
>>>        self.array = array  #! mutable default value

>>> a = ArrayDefault()
>>> len(a.array)
0
>>> a.array += [1,2,3]
>>> a.array
[1,2,3]

>>> b = ArrayDefault()
>>> b.array
[1, 2, 3]  # !!!!!
```

`a`とは全く関係ない`b`のインスタンスになぜかあらかじめ値が入っている。完全に複雑怪奇な挙動に見えるが、これが引数がimmutableでなければならない理由である。デフォルト引数のスコープはそのメソッド/関数と同じであるようで、immutableでない場合グローバル変数と同じような働きをし上記のような挙動を起こす。

よって、上記の場合はNoneをデフォルト引数にしてNoneなら[]を設定するといった処理に変える必要がある。配列同様、参照を初期値として設定するようなケースは同様に注意が必要。

[Default Parameter Values in Python](http://effbot.org/zone/default-values.htm)

## メソッドのオーバーロードができない
Pythonでは引数を変えて同名で定義するオーバーロードが使用できない。
そのためオーバーロードを使用したい場合は、デフォルト引数を使用したり内部で引数の型を判定するなどして、1メソッド内の分岐で対応する必要がある。
また、同名のクラスメソッドとメンバメソッドも許容されない。

ただ、[singledispatch](http://momijiame.tumblr.com/post/93303753531/python-singledispatch)を利用することで条件分岐を排してオーバーロード的な実装を実現できる(Python3.4からは標準搭載)。

## 演算子による計算を実装可能(オペレーターオーバーロード)
Pythonでは、`+`や`-`といった演算子による計算を実装することができる(いわゆるオペレーターオーバーロード)([参考](http://www.programiz.com/python-programming/operator-overloading))。

```py
class Point(object):
    def __init__(self, x, y):
        self.x = 0 if x is None else x
        self.y = 0 if y is None else y
    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Point(x, y)
    def __str__(self):
        return "x:{0}, y:{1}".format(self.x, self.y)

>>> print(Point(1, 2))
x:1, y:2
>>> print(Point(1, 2) + Point(1, 2))
x:2, y:4
```

また、`==`や`>`といった論理演算子の実装も可能。ただ、演算子をすべてスキなく定義するのはかなり骨が折れる。数値演算系なら自前で実装するより適切なライブラリがないかどうか確認したほうがよい。

## 型定義を記述することができる(3より)

Python3より(特にPython3.5から)、引数や関数の返り値について型を書くことができるようになった。

```py3
def greeting(name: str) -> str:
    return 'Hello ' + name
```

Python3.6からは変数にも型情報を付けることができるようになった([PEP 526](https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-pep526))。

```py3
my_string: str
my_dict: Dict[str, int] = {}
```

これはtype annotationといい、実行時にエラーを出すわけではないが事前にこの情報を使いチェックをかけることができる。チェックのためのツールとしては、[mypy](https://github.com/python/mypy)などがあり、これを利用することで実行前に型の整合性チェックを行うことができる。詳細は以下を参照。

[Pythonではじまる、型のある世界](http://qiita.com/icoxfog417/items/c17eb042f4735b7924a3)

なお、Javaのアノテーションと記述が同じに見える`@`がつくものがあるが、これはアノテーションではなく「デコレーター」であり、その挙動は全く異なりこちらは関数の実行に作用する。
デコレート、の名の通り「関数をラップする関数」として機能するのだ。

```py
import functools

def makebold(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return "<b>" + func(*args, **kwargs) + "</b>"
    return wrapper

def makeitalic(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return "<i>" + func(*args, **kwargs) + "</i>"
    return wrapper

@makebold
@makeitalic
def hello(your_name):
    return "hello {0}.".format(your_name)

>>> print hello("hoge") ## returns <b><i>hello hoge.</i></b>

```

参考：[How can I make a chain of function decorators in Python?](http://stackoverflow.com/questions/739654/how-can-i-make-a-chain-of-function-decorators-in-python)

上記は、`makebold(makeitalic(hello))(your_name)`を実行したのと同じことになる(関数定義に近いデコレーターから順次実行されていく)。
メソッド実行前にチェックを入れたい場合(権限など。[Overridesのチェック](http://stackoverflow.com/questions/1167617/in-python-how-do-i-indicate-im-overriding-a-method)などもできたりする)、また実行前後に処理を入れたい場合(実行時間の計測など)に利用される。なお、`functools.wrap`はデコレートしたことで関数の情報が元の関数でなくデコレート関数に置き換わってしまうのを防ぐためのもの([こちら](http://perezvon.hatenablog.com/entry/20090427/1240838573)参照)。

[メソッドに付与されたデコレーターを取得するのはかなり難しい](http://stackoverflow.com/questions/5910703/howto-get-all-methods-of-a-python-class-with-given-decorator)ので、メタプログラミング用途の場合(アノテーションが付与されたメソッドを取得して実行など)は潔くPython3に上げてアノテーションを利用したほうがよい。





## 名称空間とimportについて
PythonではNamespaceやpackageの宣言をしなくても、名称空間がファイルごとに(自動的に)切られるようになっている。ファイルごとに切られた名称空間の名前はファイル名と同義になるため、`package/test_class.py`の中に定義された`TestClass`を呼び出す場合、`from package.test_class import TestClass`とする必要がある。
※このため、他のパッケージ名とファイル名がバッティングするとインポートしたいパッケージがインポートできなくなったりするので注意が必要(こちらは[ファイル名をunittest.pyにしたために標準のunittestとバッティングした例](http://stackoverflow.com/questions/10756577/import-unittest-error))。`'module' object has no attribute 'xxxx'`といったエラーが出たら要注意。

また、ファイル単位で切られるため同じフォルダ内のファイルでも参照する際にimport宣言が必要になる。なお、フォルダは`__init__.py`というファイルがあるとパッケージと認識される(Python3からはなくてもよくなる)。

Javaなどと同様、パッケージ/クラス名でインポートを行いたい場合(`from package import TestClass`というような感じ)、`__init__.py`にファイルのimport文を書いておくことで対応できる。`from package`部分で読み込まれるのはフォルダ内の`__init__.py`であるため、ここにimport文があればファイルをインポートしたのと同じになるためである。

なお、相互参照しているファイルのimportの場合(AはBを参照していて、BはAを参照しているようなケース)はデッドロックのようになりインポートできなくなるので注意。これを回避するには、ファイル先頭でなく必要な処理内でimportするなどの工夫が必要になる([参考](http://stackoverflow.com/questions/17226016/simple-cross-import-in-python))。


## あらゆるファイルをスクリプトとして実行可能
`if __name__ == "__main__":`は、スクリプトとして実行された際(`python xxx.py`と実行したとき)の処理を記載できる([トップレベルのスクリプト環境参照](http://docs.python.jp/2/library/__main__.html))。

```py
if __name__ == "__main__":
    print "Run Script"
```

これはクラスを定義しているファイルだろうが関数を定義しているファイルだろうが関係ない。
そのため、ちょっと今定義しているクラスの動作を確認してみたい、という場合ファイル下部に上記のようなif文を設置しておき、その配下に動作確認用の処理を書いておけば`python xxx.py`とすることで確認が可能だ。これは非常に便利。

## 配列内で処理を記載できる(リスト内包表記)
Pythonでは以下のように、配列内での演算が可能になっている。

```py
>>> [ x for x in [1, 2, 3, 4, 5] if x > 3]
[4, 5]

>>> [ x*2 for x in [1, 2, 3, 4, 5]]
[2, 4, 6, 8, 10]

# 関数を利用することも可能
>>>def calc_double(x):
>>>    return x*2

>>> [ calc_double(x) for x in [1, 2, 3, 4, 5]]
[2, 4, 6, 8, 10] 

```

動作は`map`や`filter`といった組み込み関数と同じだが、場合によっては可読性を上げつつ簡単に書くことができる。なお、Python3からは`map`や`filter`はlistそのものでなく[iteratorを返すようになった](http://stackoverflow.com/questions/1303347/getting-a-map-to-return-a-list-in-python-3-x)ので、Python2同様listで扱いたい場合はリスト内包表記、iteratorから後続処理にチェインさせたい場合は`map`/`filter`などを使うといった棲み分けをしておくと両バージョン対応しやすい。
また、[実行速度が速いらしい](http://python-history-jp.blogspot.jp/2010/09/blog-post.html)。

Python3.6から、このリスト内包表記でも非同期のイテレーターを扱うことが可能になった([PEP 530](https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-pep530))。

```py3
result = [i async for i in async_iter() if i % 2]
result = [await fun() for fun in async_funcs if await condition()]
```

## 匿名関数の作成

Pythonでは`lambda`を使用することで匿名関数を作成できる。

```py
>>> list(map(lambda x: x * 2, range(5)))
[0, 2, 4, 6, 8]
```

上記では`map`を利用し`lambda x: x * 2`という関数を`range(5)`の各値に対して適用している。
`lambda`で作成した関数は変数に代入することも可能で、上記は以下と等価である。

```py
>>> f = lambda x: x * 2
>>> list(map(f, range(5)))
[0, 2, 4, 6, 8]
```

上記のリスト内包表記と合わせると、以下のような処理もかける。

```py
>>> f = lambda a, b: a + b
>>> [f(*z) for z in zip([1, 2, 3], [4, 5, 6])]
[5, 7, 9]
```

`zip`は複数の配列を引数にとりインデックスごとにまとめてくれる便利関数で、`zip([1, 2, 3], [4, 5, 6])`は`[(1, 4), (2, 5), (3, 6)]`となる。これを`*`を使って関数`f`の引数に展開し、処理を行っている。


## for文について
Pythonのfor文はfor eachのような形で、デフォルトではインデックスがとれない。
ループ文中でindexを利用したい場合は、以下のようにする。

```py
for index, value in enumerate(list):
    print "index:" + index
```

単純にインデックスだけで回したい場合、以下のようにも書ける(`list.length`のようなものはPythonにはないので、長さを取得する際は`len(list)`でとる)。

```py
for index in range(len(list)):
    print "index:" + index
```

便利な特性として、Pythonのfor文ではelseを設定することができる(whileの方が利用シーンは多いかもしれないが)。

```py
child = "Bob"
for c in ["Alice", "Tom", "Ann", "Cony"]:
    if c == child:
        break
else:
    print("{} is not here.".format(child))
```

`else`で定義した処理は`break`が実行されなかった場合に処理される。そのため、ループ中で検出ができなかった場合の処理を記載するのに使用できる。

## if文について
Pythonにはswitch文がないため、if-elseで代用する。
えっ、と思うかもしれないが、Pythonはインデントが定められておりifでもかなりきれいになるのでこれで困ることはあまりない。

また、このためPythonでは1行のif文(いわゆる三項演算子)が書けないのではと思う方がいるかもしれないが、Python 2.5以降では以下のように書くことができる([PEP 308 -- Conditional Expressions(条件演算式)](http://legacy.python.org/dev/peps/pep-0308/) 参照)。

```py
>>> test = 1
>>> "test eq 1" if test == 1 else "test not eq 1"
'test eq 1'
```

## 非同期処理を実装するためのシンタックスがある(3から)

Python3.5から、`async`/`await`というシンタックスを利用し非同期処理が簡単に実装できるようになった(その前から`asyncio`で実装は可能だったのだが、はれて文法として実装された)。
ある連続した処理(以下では`tasks`)を、複数プロセスで処理する場合は以下のような感じで書くことができる。

```python3
import asyncio
import random


tasks = asyncio.Queue()
for t in range(10):
    tasks.put_nowait(t)


async def execute(p):
    while not tasks.empty():
        t = await tasks.get()
        await asyncio.sleep(random.randint(0, 3))  # emulate the waiting time until task t finish
        print("Process{} done task {}".format(p, t))
    return True


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    execution = asyncio.wait([execute(process_no) for process_no in range(2)])
    loop.run_until_complete(execution)

```

実行結果は以下のようになる(※当然、実行するたびに結果は異なる)。

```py
Process1 done task 0
Process0 done task 1
Process1 done task 2
Process0 done task 3
Process1 done task 4
Process0 done task 5
Process1 done task 6
Process0 done task 7
Process0 done task 9
Process1 done task 8
```

詳細については以下の記事にまとめているので、ご参考ください。

[Pythonにおける非同期処理: asyncio逆引きリファレンス](http://qiita.com/icoxfog417/items/07cbf5110ca82629aca0)

なお、Python3.6から`yield`を使用しより簡単に非同期イテレーターを作成することが可能になった([PEP 525](https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-pep525))。

```py3
async def ticker(delay, to):
    """Yield numbers from 0 to *to* every *delay* seconds."""
    for i in range(to):
        yield i
        await asyncio.sleep(delay)
```

## 作成したパッケージの公開が可能(PyPI)

Pythonではパッケージをホスティングしている[PyPI](https://pypi.python.org/pypi)というサイトがあり、こちらに作成したパッケージを公開することでpip installなどでほかの人に広く使ってもらうことが可能になる(JavaにおけるMaven、Rubyにおけるrubygems.org、.NETにおけるnugetのようなもの)。

この方法については、普通に検索すると旧い手法がよく引っかかってしまうので、最新のアップロード方法については以下を参照されたし。

[Pythonで作成したライブラリを、PyPIに公開する](http://qiita.com/icoxfog417/items/edba14600323df6bf5e0)

## その他
ここに上げた以外のものについては、以下も参照ください。
[[python] 細かすぎて伝わりにくい、Pythonの本当の落とし穴10選](http://qiita.com/amedama/items/a03d4ae97af9aecd5966)