Python3 taste[１]（編集中）

ここではpython3の言語仕様、文法、組み込み関数について書いていきます。
ほとんど自分の備忘録用ですが。

すでに、python3.Xがインストールされていることが前提です。あと、私の環境はmacOSです。
参考にしているのはこれです。
[入門 Python 3](https://www.amazon.co.jp/%E5%85%A5%E9%96%80-Python-3-Bill-Lubanovic/dp/4873117380/ref=sr_1_1?s=instant-video&ie=UTF8&qid=1488367565&sr=8-1&keywords=%E5%85%A5%E9%96%80+python3)

![alt](https://images-na.ssl-images-amazon.com/images/I/51%2Bxv65qdBL._SX352_BO1,204,203,200_.jpg)

![にしきめ.png](https://qiita-image-store.s3.amazonaws.com/0/124460/46805ebb-c7ec-6d7a-d200-3790d4f952a7.png)



#pythonを実行してみる

```python:
KenasnoiMac:~ risa$ python3 --version
Python 3.6.0
```

#pythonスクリプトを実行してみる
何か表示してみます。

```python:
KenasnoiMac:~ risa$ python3
Python 3.6.0 (v3.6.0:41df79263a11, Dec 22 2016, 17:23:13) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello Python')
Hello Python
>>> 
```

import thisと入力すると

```python:
>>> 
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
>>>
```

↑これを訳してみると以下のようなことが書かれています。google翻訳なので
「python　禅」で検索するとしっくりとした訳例が見つかると思います。

***
PythonのZen、Tim Peters作

美しいものは醜いものよりも優れています。
明示的は暗黙的より優れています。
シンプルは複合体より優れています。
複雑なものは複雑なものよりも優れています。
フラットはネストされたものよりも優れています。
スパースは濃いよりも優れています。
読みやすさは重要です。
特殊なケースは、ルールを破るほど特別ではありません。
実用性は純粋さに勝るものの。
エラーは決して黙ってはいけません。
明示的に消音しない限り。
あいまいさに直面して、推測する誘惑を断つ。
それを行うには、1つの方法が必要です。
あなたがオランダ人でなければ、その方法は最初は明らかではないかもしれません。
今は決して良いことではありません。
しかし今は*右*よりもよくなることはありません。
実装が説明するのが難しい場合、それは悪い考えです。
実装が説明しやすい場合は、良い考えかもしれません。
名前空間はすばらしいアイディアです
***

対話コンソロールでは、最後に評価した計算結果が、_という名前の変数に保存される。

```python:
>>> 1+10
11
>>> _
11
>>> _+_
22
```


対話コンソロールを抜けるには、Ctrl+D（コントロールキーとDキーを同時に押す）、Windows環境ではCtrl+Zです。

#数値を使ってみる
Pythonには整数と浮動小数点数のサポートが組み込まれているそうです。
以下の算術演算子を使えば、数値間で計算ができます。

| 演算子 | 計算 | サンプル | 結果 |
|:---|:---|:---|:---|
|+|加算|1+1|2|
|-|減算|10-1|9|
|*|乗算|4*6|24|
|/|浮動小数点数の除算|5.0/2.0|2.5|
|//|整数の除算（切り捨て）|5//2|2|
|%|剰余|5%4|1|
|**|指数|2**3|8|

対話コンソロールを立ち上げます。

```python:
KenasnoiMac:~ risa$ python3
Python 3.6.0 (v3.6.0:41df79263a11, Dec 22 2016, 17:23:13) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 1+2+3+4+5+6+7+8+9+10
55
>>>
>>> (1+10)*10/2
55
>>> 
>>> 10/3
3.3333333333333335
>>> 3.3333333333333335 * 3
10.0
>>> 5/2
2.5
>>> 5/3
1.6666666666666667
>>> 1.6666666666666667 * 3
5.0
>>> 1/3
0.3333333333333333
>>> 0.3333333333333333 * 3
1.0
```

なんかいい感じに見えますが以下はどうでしょう。

```python:
>>> 0.3 - 0.2
0.09999999999999998
>>>
>>> 0.3 - 0.1
0.19999999999999998
```

微妙に結果がずれています。
10進不動小数点数で正確な結果が欲しい場合は、decimalを使います。

```python:
>>> from decimal import *
>>> Decimal('0.3') - Decimal('0.2')
Decimal('0.1')
>>> float(Decimal('0.1'))
0.1
>>>
>>> Decimal('0.3') - Decimal('0.1')
Decimal('0.2')
>>> float(Decimal('0.2'))
0.2
>>>
```

重要なので、後で個別に特集します。

#変数を使ってみる
**python変数の極めて重要なポイント**
・変数はただの名前
・代入しても値はコピーされない
・データを入れているオブジェクトに名前をつけるだけ
・名前は値自体ではなく値の参照

変数を使ってみましょう。

```python:
>>> a = 1
>>> a
1
>>> type(a)
<class 'int'>
>>> b = "abc"
>>> b
'abc'
>>> type(b)
<class 'str'>
>>> a + b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>>
```

数値型と文字列型を足そうとしたので、エラーが出ています。
この場合以下のようにaをstr()でキャストすると、エラーになりません。

```python:
>>> str(a) + b
'1abc'
```

```python:
>>> a = 1
>>> a
1
>>> b = a + 1
>>> b
2
```

**比較演算子**
条件が成立すればTrueが、成立しなければFalseが返る。

|演算子|意味|
|:---|:---|
|x < y |xはyより小さい|
|x <= y |xはyより小さいか等しい|
|x > y |xはyより大きい|
|x >= y |xはyより大きいか等しい|
|x == y |xとyは等しい|
|x != y |xとyは等しくない|
|x is y |xとyは同じオブジェクト|
|x is not y |xとyは同じオブジェクトではない|
|x in y |xはyに含まれる|
|x not in y |xはyに含まれない|

pythonではある値が、一定の範囲にあるかチェックする条件式を以下のように簡潔にかけます。

```python:
>>> abc = 99
>>> if 0 < abc <100:
...     print("0より大きく100未満です")
... else:
...     print("範囲外です")
...
0より大きく100未満です
```

**変数名のルール**
・英数字またはアンダースコアのみ使用できる。
・１文字目はアルファベットまたはアンダースコア _ のみ使用できる。
　→よって一文字目が数字は使用できない
・予約語は変数名として使用できない。
・アルファベットの大文字、小文字は区別される。
　→abcとAbcは別の変数として扱われる
・予約語は使用できない。

**pythonの予約語**

```python:
>>> import keyword
>>> keyword.kwlist
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 
'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 
'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 
'raise', 'return', 'try', 'while', 'with', 'yield']
>>> 
```

#文字列
pythonでの文字列は、「'」（シングルクォーテーション）と「"」（ダブルクォーテーション）「"""」（トリプルクォート）で囲まれたものが対象です。

```python:
>>>
>>> a = "abc"
>>> a
'abc'
>>> b = 'qsp'
>>> b
'qsp'
>>> c = """
... qqq
... qqqq
... qqqqq
... qqqqqq
... """
>>> c
'\nqqq\nqqqq\nqqqqq\nqqqqqq\n'
>>> 
>>> print(c)

qqq
qqqq
qqqqq
qqqqqq

>>>
>>> abc = "'aaaaa'"
>>> abc
"'aaaaa'"
>>> bbb = '"bbbbb"'
>>> bbb
'"bbbbb"'
```

「"""」（トリプルクォート）は入力された、改行コードがそのまま出力されます。

**文字列の連結**
文字列と文字列を足すと連結することができる。

```python:
>>> a = "abc"
>>> a
'abc'
>>> b = 'qsp'
>>> b
'qsp'
>>> a + b
'abcqsp'
>>>
```

複合演算子を使用することもできます。

```python:
>>> str_str = "a"
>>> str_str += "b"
>>> str_str += "c"
>>> str_str += "d"
>>> str_str += "e"
>>> str_str
'abcde'
>>>
```

**文字列を繰り返す**
文字列をかけます。

```python:
>>> print("$" * 30)
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
>>> print("あっちこっち" * 3)
あっちこっちあっちこっちあっちこっち
>>> aaa = "あっちこっち" * 3
>>> aaa
'あっちこっちあっちこっちあっちこっち'
>>>
```

**文字（列）の置換**
文字列の置換は「replace」を使用します。

```python:
>>> str = "Hello World"
>>> print(str.replace("World", "Python"))
Hello Python
```

**文字列の分割**
文字列の分割は「split」を使用します。
これは、後述のリストを返します。

```python:
>>> str = "abc|123|あああ|$$$"
>>> abc = str.split('|')
>>> abc
['abc', '123', 'あああ', '$$$']
```

**ゼロで桁埋め**
ゼロで桁埋めする場合は「zfill」を使います。

```python:
>>> a1 = '1'
>>> a2 = '2'
>>> print(a1.zfill(2))
01
>>> print(a2.zfill(2))
02
>>>
```

**ゼロ以外で桁埋め**
文字列の左に値を埋める場合は「rjust」を使います。

```python:
>>> b1 = "123"
>>> b2 = "12"
>>> print(b1.rjust(5,'□'))
□□123
>>> print(b1.rjust(5,'0'))
00123
>>> print(b2.rjust(10,'□'))
□□□□□□□□12
>>> print(b2.rjust(10,'0'))
0000000012
>>>
```

**大文字・小文字変換**
指定の文字列を大文字・小文字へ変換するには「upper」または「lower」を使います。

```python:
>>> str = "Hello Python"
>>> print(str.upper())
HELLO PYTHON
>>> print(str.lower())
hello python
```

**文字列の検索**
演算子の「in」を使います。

```python:
>>> "Python" in "Hello Python"
True
>>> "World" in "Hello Python"
False
```

#Pythonのコンテナ（容器）を使ってみる
##**リスト型 (list)**
リストはミュータブル（変更可能）なシーケンスで、複数のデータを並べて管理し効率的に使用します。

空のリストを宣言し後から追加できます。
型の違うデータが混じっていることに注目してください。

```python:
>>> a = []
>>> a.append('123')
>>> a.append(123)
>>> a.append(123.786)
>>> a
['123', 123, 123.786]
>>> type(a)
<class 'list'>
>>> type(a[0])
<class 'str'>
>>> type(a[1])
<class 'int'>
>>> type(a[2])
<class 'float'>
```

もちろん最初に初期値を代入することも可能です。

```python:
>>> b = ['abc',21.98,500,[3,4,5],"@@"]
>>> b
['abc', 21.98, 500, [3, 4, 5], '@@']
```

上のbのリストの21.98を30に変更してみます。
※リストのインデックスは0（ゼロ）から始まります。

```python:
>>> b[1] = 30
>>> b
['abc', 30, 500, [3, 4, 5], '@@']
```

変わりましたね。

リストの要素数は下記の方法で求めることができます。

```python:
>>> prog
['Java', 'c', 'c#', 'c++', 'perl', 'php', 'python', 'python']
>>> len(prog)
8
```

###★リスト型についてもう少し
list.**append(x)**
リストの末尾に要素を一つ追加します。

```python:
>>> prog = ["c","Java","python","php","python"]
>>> prog
['c', 'Java', 'python', 'php', 'python']
>>> prog.append("perl")
>>> prog
['c', 'Java', 'python', 'php', 'python', 'perl']
```

list.**extend(L)**
指定したリスト中のすべての要素を対象のリストに追加し、リストを拡張します。

```python:
>>> prog
['c', 'Java', 'python', 'php', 'python', 'perl']
>>> plus = ["c#","VBA","ruby"]
>>> prog.extend(plus)
>>> prog
['c', 'Java', 'python', 'php', 'python', 'perl', 'c#', 'VBA', 'ruby']
```

list.**insert(i, x)**
指定した位置に要素を挿入します。第 1 引数は、リストのインデクスで、そのインデクスを持つ要素の直前に挿入が行われます。従って、 a.insert(0, x) はリストの先頭に挿入を行います。

```python:
>>> prog
['c', 'Java', 'python', 'php', 'python', 'perl', 'c#', 'VBA', 'ruby']
>>> prog.insert(1,"c++")
>>> prog
['c', 'c++', 'Java', 'python', 'php', 'python', 'perl', 'c#', 'VBA', 'ruby']
```

list.**remove(x)**
リスト中で、値 x を持つ最初の要素を削除します。該当する項目がなければエラーとなります。

```python:
>>> prog
['c', 'c++', 'Java', 'python', 'php', 'python', 'perl', 'c#', 'VBA', 'ruby']
>>> prog.remove('ruby')
>>> prog
['c', 'c++', 'Java', 'python', 'php', 'python', 'perl', 'c#', 'VBA']
>>> prog.remove('ruby')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
```

list.**pop([i])**
リスト中の指定された位置にある要素をリストから削除して、その要素を返します。インデクスが指定されなければ、 a.pop() はリストの末尾の要素を削除して返します。この場合も要素は削除されます。 (メソッドの用法 (signature) で i の両側にある角括弧は、この引数がオプションであることを表しているだけなので、角括弧を入力する必要はありません。

```python:
>>> prog
['c', 'c++', 'Java', 'python', 'php', 'python', 'perl', 'c#', 'VBA']
>>> prog.pop()
'VBA'
>>> prog
['c', 'c++', 'Java', 'python', 'php', 'python', 'perl', 'c#']
```

list.**clear()**
リスト中の全ての要素を削除します。

```python:
>>> plus
['c#', 'VBA', 'ruby']
>>> plus.clear()
>>> plus
[]
```

list.**index(x[, start[, end]])**
リスト中で、値 x を持つ最初の要素の位置をゼロから始まる添字で返します。 該当する要素がなければ、ValueError を送出します。
任意の引数である start と end はスライス記法として解釈され、x の探索範囲を指定できます。返される添字は、start 引数からの相対位置ではなく、リスト全体の先頭からの位置になります。

```python:
>>> prog
['c', 'c++', 'Java', 'python', 'php', 'python', 'perl', 'c#']
>>> prog.index("php")
4
>>> prog.index("python",4,7)
5
```

list.**count(x)**
リストでの x の出現回数を返します。

```python:
>>> prog
['c', 'c++', 'Java', 'python', 'php', 'python', 'perl', 'c#']
>>> prog.count('python')
2
>>> prog.count("ruby")
0
```

list.**sort(key=None, reverse=False)**
リストの項目を、インプレース演算 (in place、元のデータを演算結果で置き換えるやりかた) でソートします。引数はソート方法のカスタマイズに使えます。

```python:
>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
```

list.**reverse()**
リストの要素を、インプレース演算で逆順にします。

```python:
>>> a
[1, 2, 3, 4, 5]
>>> a.reverse()
>>> a
[5, 4, 3, 2, 1]
```

list.**copy()**
リストの浅い (shallow) コピーを返します。

```python:
>>> a
[5, 4, 3, 2, 1]
>>> a.copy()
[5, 4, 3, 2, 1]
```

##**del文**
リストから要素を削除する際、値を指定する代わりにインデックスを指定する方法があります。それが del 文です。これは pop() メソッドと違い、値を返しません。 del 文はリストからスライスを除去したり、リスト全体を削除することもできます。

```python:
>>> prog
['Java', 'c', 'c#', 'c++', 'perl', 'php', 'python', 'python']
>>> del prog[2]
>>> prog
['Java', 'c', 'c++', 'perl', 'php', 'python', 'python']
>>> del prog
>>> prog
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'prog' is not defined
```

変数自体を消して、それを参照しようとしたためエラーになっています。

##**タプル(tuple)**
タプルはイミュータブルな（生成した後に変更ができない）リストです。
タプルはdict のキーとして使え、 set や frozenset インスタンスに保存できます。

```python:
>>> a = (1,2,3,4,5)
>>> a
(1, 2, 3, 4, 5)
>>> a[0] = 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
```

変更しようとするとエラーになります。

```python:
>>> a
(1, 2, 3, 4, 5)
>>> len(a)
5
```

リスト同様、要素数は上記の方法で求めることができます。

```python:
>>> t = 12345, 54321, 'hello!'
>>> t
(12345, 54321, 'hello!')
>>> x, y, z = t
>>> x
12345
>>> y
54321
>>> z
'hello!'
```

「x, y, z = t」の部分はアンパック代入です。
ｘ、ｙ、ｚそれぞれにtの値が個別に代入されます。