【Python】Python3.0チートシート

# 演算子

|演算子|意味|例|結果|
|---|---|---|---|
|+|加算|5 + 8|13|
|-|減算|90 - 10|80|
|*|乗算|4 * 7|28|
|/|浮動小数点の除算|7 / 2|3.5|
|//|整数の除算（切り捨て）|7 // 2|3|
|%|剰余|7 % 3|1|
|**|指数|3 ** 4|81|

比較演算子

|意味|演算子|
|---|---|
|等しい|==|
|等しくない|!=|
|より小さい|<|
|以下|<=|
|より大きい|>|
|以上|>=|
|要素になっている|in ...|




# 型変換

```python:
#文字列に変換
str()

#整数に変換
int()

#浮動小数点に変換
float()
```


#文字列操作

## *による繰り返し

```python:
start = 'Na' * 4 + '\n'
middle = 'Hey' * 3 + '\n'
end = 'Goodbye.'
print(start + start + middle + end)
```

```
Na Na Na Na
Na Na Na Na
Hey Hey Hey
Goodbye.
```


## []による文字の抽出

```python:
letters = 'abcdefghijklmnopqrstuvwxyz'
print(letters[0])
print(letters[-1])
print(letters[-2])
```

```
a
z
y
```


## [start: end: step]によるスライス
* [:]は，先頭から末尾までのシーケンス全体を抽出する.
* [start: ]は，startオフセットから末尾までのシーケンスを抽出する．
* [ :end]は，先頭からend-1オフセットまでのシーケンスを抽出する．
* [start: end: step]は，step文字ごとにstartオフセットからend-1オフセットまでのシーケンスを抽出する．


```python:
letters = 'abcdefghijklmnopqrstuvwxyz'
print('1', letters[:])
print('2', letters[20:])
print('3', letters[10:])
print('4', letters[12:15])
print('5', letters[-3:])
print('6', letters[18:-3])
print('7', letters[-6:-2])
print('8', letters[::7])
print('9', letters[4:20:3]])
print('10', letters[19::4])
print('11', letters[:21:5])
print('12', letters[-1::-1])
print('13', letters[::-1])
print('14', letters[-50:])
print('15', letters[-51:-50])
print('16', letters[:71])
print('17', letters[70:71])
```

```
1 abcdefghijklmnopqrstuvwxyz
2 uvwxyz
3 klmnopqrstuvwxyz
4 mno
5 xyz
6 stuvw
7 uvwx
8 ahov
9 ehknqt
10 tx
11 afkpu
12 zyxwvutsrqponmlkjihgfedcba
13 abcdefghijklmnopqrstuvwxyz
14 abcdefghijklmnopqrstuvwxyz
15
16 abcdefghijklmnopqrstuvwxyz
17
```

## len()による長さの取得

```python
letters = 'abcdefghijklmnopqrstuvwxyz'
#文字列の長さ
print(len(letters))
#リストの長さ
Array = ['a', 'b', 'c']
print(len(Array))
```
```
26
3
```


## split()による分割

```python
todos = 'get gloves,get mask,give cat vitamins,call ambulance'
#セパレータを指定する場合
print(todos.split(','))
#セパレータを指定しない場合（改行，スペース，タブ）
print(todos.split())
```

```
['get gloves', 'get mask', 'give cat vitamins', 'call ambulance']
['get', gloves,get', 'mask,give', 'cat', 'vitamins,call', 'ambulance']
```

## join()による結合

```python
crypto_list = ['Yeti', 'Bigfoot', 'Loch Ness Monster']
crypto_string = ', '.join(crypto_list)
print('Found and signing book deals:', crypto_string)
```

```
Found and signing book deals: Yeti, Bigfoot, Loch Ness Monster
```

## その他便利な文字列関数

```python
poem = '''All that doth flow we cannot liquid name
Or else would fire and water be the same;
But that is liquid which is moist and wet
Fire that property can never get.
Then 'tis not could that doth the fire put out
But 'tis the wet that makes it die, no doubt.'''

#最初の13字
print(poem[:13])

#何文字あるか
print(len(poem))

#先頭が'All'かどうか
print(poem.startswith('All'))

#末尾が'That\'s all, folks!'になっているかどうか
print(poem.endswith('That\'s all, folks!'))

#'the'という単語が最初に現れる箇所のオフセットを調べる
print(poem.find('the'))

#最後のオフセット
print(poem.rfind('the'))

#'the'という３文字のシーケンスは全部で何個あるか
print(poem.count('the'))

#全て英字または数字かどうか
print(poem.isalnum())
```



```
All that doth
250
True
False
73
214
3
False
```






## 大文字と小文字の区別・配置

```python:
setup = 'a duck goes into a bar...'

#'.'を取り除く
print(setup.strip('.'))

#先頭の単語のみタイトルケースに
print(setup.capitalize())

#全ての単語をタイトルケースに
print(setup.title())

#全ての文字を大文字に
print(setup.upper())

#全ての文字を小文字に
print(setup.lower())

#大文字小文字を逆に
print(setup.swapcase())

#30字分のスペースの中央に文字列を配置（レイアウトを操作）
print(setup.center(30))

#左側に配置
print(setup.ljust(30))

#右側に配置
print(setup.rjust(30))
```

```
a duck goes into a bar
A duck goes into a bar...
A Duck Goes Into A Bar
A DUCK GOES INTO A BAR...
a duck goes into a bar...
A DUCK GOES INTO A BAR...
      a duck goes into a bar...
a duck goes into a bar...
                a duck goes into a bar...
```



## replace()による置換

```python:
setup = 'a duck goes into a bar...'

print(setip.replace('duck','marmoset'))

#max100回置換
print(setip.replace('a','a famous',100))
```

```
a famous duck goes into a famous bar
a famous duck goes into a famous ba famousr...
```
部分文字列が一つの単語になっている場合や単語の先頭になっている場合といった条件を指定したい場合がある．
このような場合は**正規表現**が必要になってくる．










# リストとタプルと辞書と集合
`リスト`：ミュータブル（要素の挿入と削除と書き換えが可能）
`タプル`：イミュータブル（要素の挿入と削除と書き換えが不可能）


## リスト
### []またはlist()によるリストの作成

```python:
empty_list_a = []
empty_list_b = list()
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
```

### list()で文字列を文字列リストに変換

```python:
print(list('cat'))
```

```
['c','a','t']
```
### list()でタプルをリストに変換

```python:
a_tuple = ('ready','fire','aim')
print(list(a_tuple))
```

```
['ready','fire','aim']
```


### スライスによるサブシーケンスの取り出し


```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(weekdays[0:2])
print(weekdays[::2])
print(weekdays[::-2])
print(weekdays[::-1])
```

```
['Monday','Tuesday']
['Monday','Wednesday','Friday']
['Friday','Wednesday','Monday']
['Friday','Thursday','Wednesday','Tuesday','Monday']
```

### append()による末尾への要素の追加

```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print (weekdays.append('Saturday'))
```

```
['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']
```

### extend()または+=を使ったリストの結合
```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekends = ['Saturday','Sunday']
print (weekdays.extend(weekends))
```
```
['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
```

### insert()によるオフセットを指定した要素の追加

```python:
weekdays = ['Monday','Tuesday','Thursday','Friday']
print(weekdays.insert(2,'Wednesday'))
```
```
['Monday','Tuesday','Wednesday','Thursday','Friday']
```
ちなみに，末尾を超えるオフセットを指定するとappend()と同じようにリストの末尾に挿入される．

### delによる指定したオフセット要素の削除

```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
del weekdays[-1]
print(weekdays)
```
```
['Monday','Tuesday','Wednesday','Thursday']
```
delはPythonの文でありリストのメソッドではないためdel()のようにはならない．

### remove()による値に基づく要素の削除

```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(weekdays.remove(Wednesday))
```

```
['Monday','Tuesday','Thursday','Friday']
```


### pop()でオフセットを指定して要素を取り出しそれと同時にリストから削除する

引数を指定しない場合，オフセットとして`-1`が使われる．

```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(weekdays.pop())
print(weekdays)
print(weekdays.pop(1))
print(weekdays)
```

```
Friday
['Monday','Tuesday','Wednesday','Thursday']
Tuesday
['Monday','Wednesday','Thursday']
```

### index()で要素の値から要素のオフセットを知る

```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(weekdays.index(Wednesday))
```

```
2
```

### inを使った値の有無テスト

```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print('Monday' in weekdays)
print('Sunday' in weekdays)
```

```
True
False
```

### count()を使った値の個数の計算

```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday','Monday','Monday']
print(weekdays.count(Monday))
```

```
3
```


### join()による文字列への変換
split()の逆版だと思えばわかりやすい．

```python:
weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday']
separator = ' * '
print(separator.join(weekdays))
```

```
Monday * Tuesday * Wednesday * Thursday * Friday
```



### sort()による要素の並べ替え

```python:
abc = ['d','b','c','e','a']
print(abc.sort())
print(abc.sort(reverse=True))
```

```
['a','b','c','d','e']
['e','d','c','b','a']
```

### len()による長さの取得

```python:
abc = ['d','b','c','e','a']
print(len(abc))
```
```
5
```

### =による代入とcopy()によるコピー

```python:
a = [1,2,3]
print(a)
b = a
print(b)
a[0] = 'surprise'
print(a)
print(b)
```

```
[1,2,3]
[1,2,3]
['surprise',2,3]
['surprise',2,3]
```
aを書き換えるとbにも影響が出る

```python:
a = [1,2,3]
b = a.copy()
a[0] = 'surprise'
print(a)
print(b)
```

```
['surprise',2,3]
[1,2,3]
```
aを書き換えてもbに影響がない．



## タプル
### ()を使ったタプルの作成

```python:
empty_tuple = ()
print(empty_tuple)

#一個以上の要素を持つタプルは，個々の要素をカンマで区切っていく．（２つ以上の要素を持つ場合は最後の要素の後ろにカンマをつける必要はない）
one_marx = 'Groucho',
print(one_marx)
```

```
()
('Groucho',)
```

Pythonは，タプルをエコー表示する時にかっこを追加するが，定義する時にかっこが必要になるわけではない．タプルを定義するのは，値を区切るカンマだ．だからといってかっこを使ってもエラーにならない．値全体をかっこで囲むことは認められていて，そうすればタプルだとわかりやすくなる．

タプルのアンパック

```python:
marx_tuple = ('Groucho', 'Chico', 'Harpo')
a, b, c = marx_tuple
print(a)
print(b)
print(c)
```

```
Groucho
Chico
Harpo
```

## 辞書
### 辞書作成

```python:
#空の辞書
empty_dict = {}
#辞書作成
dragonball = {
"goku":1000,
"pikkoro": 900,
"begeta": 10000,
}
```

### dict()を使った変換

```python:
lol = [['a','b'],['c','d'],['e','f']]
print(dict(lol))
```

```
{'c':'d', 'a':'b', 'e':'f'}
```


### [key]による要素の追加と変更

```python:
pythons = {
'Chapman':'Graham',
'Cleese':'John',
'Idle':'Eric',
'Palin':'Michael',
}

pythons['Gilliam']='Gerry'

print(pythons)
```

```
{'Chapman':'Graham','Cleese':'John','Idle':'Eric','Gilliam':'Gerry','Palin':'Michael',}
```

### update()による辞書の結合

```python:
dic1 = {'python':100, 'java':50, 'C':30}
dic2 = {'SQL':20, 'Ruby':40, 'Perl':5}
print(dic1.update(dic2))
```

```
{'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
```

順序は保持されないことに注意

### delによる指定したキーを持つ要素の削除

```python
dic = {'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
del dic[java]
print(dic)
```

```
 {'python':100, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
```

### clear()による全ての要素の削除
```python
dic = {'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
print(dic.clear())
```
```
{}
```

### inを使ったキーの有無チェック
```python
dic = {'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
print('python' in dic)
print('reactJS' in dic)
```

```
True
False
```

### [key]による要素の取得
```python
dic = {'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
print(dic['python'])
```
```
100
```


### keys()で全てのキーを取得

```python
dic = {'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
print(dic.keys())
```
```
['python', 'java', 'C', 'SQL', 'Ruby', 'Perl']
```
順序が保持されないことに注意

### values()で全ての値を取得

```python
dic = {'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
print(dic.values())
```
```
[100, 50, 30, 20, 40, 5]
```
順序が保持されないことに注意



### =による代入とcopy()によるコピー

```python
#代入
dic = {'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
dic['reactJS'] = 200
print(dic)

#コピー
dic = {'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
dic_cp = dic.copy()
dic_cp['reactJS'] = 200
print(dic)
print(dic_cp)
```

```
{'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5, 'reactJS':200}

{'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}
{'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5, 'reactJS':200}
```
順序は保持されないことに注意

## 集合

### set()で集合を定義
set()または一個以上のカンマで区切り，{}で囲む．

```python
empty_set = set()
example = {'python', 'perl', 'c', 'c', 'Ruby'}

print(empty_set)
print(example)
```
```
set()
{'python', 'perl', 'c', 'c', 'Ruby'}
```
辞書と同様，順序は保持しないので注意が必要

### set()による他のデータ型から集合への変換

```python
#文字列->文字の集合
print(set('letters'))

#リスト->集合
print(set(['python', 'perl', 'c', 'c', 'Ruby']))

#タプル->集合
print(set(('python', 'perl', 'c', 'c', 'Ruby')))

#辞書->keyの集合
print(set({'python':100, 'java':50, 'C':30, 'SQL':20, 'Ruby':40, 'Perl':5}))
```
```
{'l','e','t','r','s'}
{'python', 'perl', 'c', 'Ruby'}
{'python', 'perl', 'c', 'Ruby'}
{'python', 'java', 'C', 'SQL', 'Ruby', 'Perl'}
```
同じく順序は保持しないです


###inを使った値の有無テスト

```python
#key:料理名，value:材料の辞書
foods = {
    'カレー':{'じゃがいも','にんじん','たまねぎ','ごはん','にく'},
    'カルボナーラ':{'にく','めん'},
    'ラーメン':{'にく','めん','ねぎ','しょうゆ'}
}

#材料に'じゃがいも'を使う料理のみに絞る
for name, ingredient in foods.items():
    if 'じゃがいも' in ingredient:
        print(name)

#'にく'と'めん'はあるけど，'ねぎ'がない料理のみに絞る
for name, ingredient in foods.items():
    if 'にく' in ingredient and 'めん' in ingredient and not 'ねぎ' in ingredient:
        print(name)
```

```
カレー
カルボナーラ
```

### 組み合わせと演算
積集合演算子＆

```python
for name, ingredient in foods.items():
    if ingredients & {'にんじん','たまねぎ'}:
        print(name)
for name, ingredient in foods.items():
    if 'にく' in ingredient and not ingredient & {'たまねぎ','ごはん'}:
        print(name)
```

```
カレー

カルボナーラ
ラーメン
```


```python
a = {1,2}
b = {2,3}

#積集合
print(a & b)
print(a.intersection(b))

#和集合
print(a | b)
print(a.union(b))

#差集合(第１の集合には含まれているものの，第２の集合には含まれていない要素の集合)
print(a - b)
print(a.difference(b))

#排他的論理和（どちらか片方には含まれているが，両方には含まれていない要素の集合）
print(a ^ b)
print(a.symmetric_difference(b))
```

```
{2}
{2}
{1,2,3}
{1,2,3}
{1}
{1}
{1,3}
{1,3}
```

## 大きいデータ構造
例えば，辞書のキーはいミュータブルでなければならない．そのため，リスト，辞書，集合は他の辞書のキーにはなれない．
しかし**タプルだけはキーになれる**例えば，関心のある位置のGPS座標（緯度，経度，高度）をインデックスとすることができる．

例

```python
houses = {
    (44.79, -93.14, 285):'My House',
    (38.89, -77.03, 13):'The White House'
}
```

# コード構造
## if elif elseによる比較
### TrueとFalse
チェックしている要素がブール値でなければどうなるのだろうか．
偽は必ずしも明示的にFalseである必要はない．
例えば以下に示すものは全てFalseとみなされる．

|Falseとみなされるもの|値|
|---|---|
|ブール値|False|
|null|None|
|整数のゼロ|0|
|floatのゼロ|0.0|
|空文字列|''|
|空リスト|[]|
|空タプル|()|
|空辞書|{}|
|空集合|set()|

## whileによる反復処理

```python
count = 1
while count <= 5:
    print(count)
    count += 1
```
```
1
2
3
4
5
```


### breakによるループ処理
'q'を入力されたら終了

```python
while True:
    stuff = input("String to capitalize [type q to quit]: ")
    if stuff == "q":
        break
    print(stuff.capitalize())
```

```
String to capitalize [type q to quit]: test
Test
String to capitalize [type q to quit]: hey, it works
Hey, it works
String to capitalize [type q to quit]: q
```



### continueによるイテレーションの開始

```python
while True:
    value = input("Integer, please [q to quit]: ")
    if value == 'q':
        break
    number = int(value)
    if number % 2 == 0: #偶数
        continue
    print(number, "squared is", number*number)
```
```
Integer, please [q to quit]: 1
1 squared is 1
Integer, please [q to quit]: 2
Integer, please [q to quit]: 3
3 squared is 9
Integer, please [q to quit]: q
```

## forによる反復処理

Pythonはリストや集合，辞書をそのままループで回せる．
Pythonの旨味はここだ．

CやJavaのようにシーケンスをループで処理するとこのようにかく

```python
lang = ['Python','Ruby','C','Java']
current = 0
while current < len(lang):
    print(lang[current])
    current += 1
```
```
Python
Ruby
C
Java
```

Pythonらしく書くとこんな感じ

```python
lang = ['Python','Ruby','C','Java']
for n in lang:
    print(n)
```
```
Python
Ruby
C
Java
```

少ない行数でシンプルにかける．



### zip()を使った複数のシーケンスの反復処理
正直これはPythonのユニークなテクニックだと思う．
こんな機能があれば便利だと昔から思ってた．

```python
days = ['Monday','Tuesday','Wednesday']
fruits = ['banana','orange','peach']
drinks = ['coffee','tea','beer']
desserts = ['tiramisu','ice cream','pie','pudding']
for day, fruit, drink, dessert in zip(days, fruits, drinks, desserts):
    print(day, ": drink", drink, "- eat", fruit, "- enjoy", dessert)
```

```
Monday : drink coffee - eat banana - enjoy tiramisu
Tuesday : drink tea - eat orange - enjoy ice cream
Wednesday : drink beer -eat peach -enjoy pie
```
zip()は最もサイズの小さいシーケンス要素を処理し尽くした時に止まる．
この例では，リストの中の一つ（desserts）だけが他のリストよりも長い．
そのため，他のリストを長くしない限り，プリン(pudding)をもらえる人はいない．

zip()を使えば複数のシーケンスを辿ってオフセットが共通する要素からタプルを作ることができる．
例えば，同じ意味の英単語と日本語の二つのタプルを作ってみる．

```python
english = 'Monday', 'Tuesday', 'Wednesday'
japanese = '月曜日', '火曜日', '水曜日'
print (list(zip(english, japanese)))
print (dict(zip(english, japanese)))
```

```
[('Monday', '月曜日'),('Tuesday','火曜日'),('Wednesday','水曜日')]
{'Monday': '月曜日', 'Tuesday': '火曜日', 'Wednesday': '水曜日'}
```

### range()による数値シーケンスの作成

```python
for x in range(0,3):
    print(x)
```

```
0
1
2
```

```python
print(list(range(0,3)))
```

```
[0,1,2]
```

```python
for x in range(2,-1,1):
    print(x)
```
```
2
1
0
```

```python

print(list(range(2,-1,-1)))
```
```
[2,1,0]
```

```python
print(list(range(0,11,2)))
```
```
[0,2,4,6,8,10]
```

## 内包表記=スマートなコードをかく！
内包表記は，Pythonのデータ構造をコンパクトに作れる形式．
内包表記を使えば，ループや条件テストが一行で済む．
内包表記を使えるようになれば中級・上級者の仲間入りだ！！！

###リスト内包表記


以下全部同じこと

```python
num_list = []
num_list.append(1)
num_list.append(2)
num_list.append(3)
num_list.append(4)
num_list.append(5)
```

```python
num_list = []
for num in range(1,6):
    num_list.append(num)
```

```python
num_list = list(range(1,6))
```

これらは全く同じことである．このような場合，
リスト内表記を使った方がよりPythonらしいスマートなコードになる．

`[expression for item in iterable]`

```python
num_list = [num for num in range(1,6)]
print(num_list)
```

```
[1,2,3,4,5]
```

```python
num_list = [num-1 for num in range(1,6)]
print(num_list)
```

```
[0,1,2,3,4]
```

```python
a_list = [num for num in range(1,6) if num % 2 == 1]
print(a_list)
```

```
[1,3,5]
```

最後に，ループをネストできるのと同じように，内包表記でもfor..節を複数使うことができる．

```python
rows = range(1,4)
cols = range(1,3)
for row in rows:
    for col in cols:
        print(row,col)
```

```
1 1
1 2
2 1
2 2
3 1
3 2
```

```python
rows = range(1,4)
cols = range(1,3)
cells = [(row, col) for row in rows for col in cols]
for cell in cells:
    print(cell)
```

```
(1, 1)
(1, 2)
(2, 1)
(2, 2)
(3, 1)
(3, 2)
```
尚，タプルのアンパックを利用してcellリストを反復処理しながらタプルからrow, colの値を引き抜くこともできる．

```python
for row, col in cells:
    print (row, col)
```

### 辞書包括表記
リストだけでなく辞書にも内包表記がある．

`{key_item: value_item for item in iterable}`


```python
word = 'letters'
letter_counts = {letter: word.count(letter) for letter in word}
print(letter_counts)
```

```
{'l':1, 'e':2, 't':'2', 'r':1, 's':1}
```


### 集合内包表記

`{item for item in iterable}`


```python
a_set = {num for num in range(1,6) if num % 3 == 1}
print(a_list)
```

```
{1,4}
```


## 関数

### 位置引数
Pythonでは最も一般的な引数の受け取り方だと思う．

```python
def spec(os, lang):
    return {'os':os, 'lang':lang}

print(spec('mac', 'Python'))
```
```
{'os':'mac', 'lang':'Python'}
```

### キーワード引数

```python
def spec(os, lang):
    return {'os':os, 'lang':lang}

print(spec(lang ='Python', os = 'mac'))
```
```
{'os':'mac', 'lang':'Python'}
```


### デフォルト引数値の指定

仮引数にはデフォルト値を指定できる．このデフォルト値は，呼び出し元が対応する実引数を渡してこなかった時に使われる．このパッとしない響きの機能が，実際にはかなり役にたつ．

```python
def spec(os, lang='C'):
    return {'os'= os, 'lang'= lang}

print(spec('mac'))
```

```
{'os':'mac', 'lang':'C'}
```

```python
def spec(os, lang='C'):
    return {'os'= os, 'lang'= lang}

print(spec('mac', 'Perl'))
```

```
{'os':'mac', 'lang':'Perl'}
```



### *による位置引数のタプル化

関数定義の中で仮引数の一部として*を使うと，可変個の位置引数をタプルにまとめてその仮引数にセットする．
次の例ではprint_args()関数に渡された実引数から作ったタプルをargs仮引数にセットしている．

```python
def print_args(*args):
    print('Positional argument tuple:', args)
```

実引数なしで呼び出すと，*argsには何も入らない．

```python
print_args()
```

```
Positional argument tuple: ()
```

```python
def print_more(required1, required2, *args):
    print('Need this one:', required1)
    print('Need this one too:', required2)
    print('All the rest:', args)


print_more('cap', 'gloves', 'scarf', 'monocle', 'mustache wax')
```

```
Need this one: cap
Need this one too: gloves
All the rest: ('scarf', 'monocle', 'mustache wax')
```


### **によるキーワード引数の辞書化

```python
def print_kwargs(**kwargs):
    print('Keyword arguments:', kwargs)

print_kwargs(wine='merlot', entree='mutton', dessert='macaroon')
```

```
Keyword arguments: {'dessert': 'macaroon', 'wine':'merlot', 'entree':'mutton'}
```
関数内では，kwargsは辞書である．


### 無名関数：ラムダ関数

Pythonでは，ラムダ関数は，一つの文で表現される無名関数だ．
この具体的な意味を示すために，まず通常の関数を使った例を作ってみよう．
引数は次のとおりだ．

words
    単語のリスト
func
    words内の個々の単語に適用される関数


```python
def edit_story(words, func):
    for word in words:
        print(func(word))
```

この関数を試すには，単語のリストと個々の単語に適用される関数が必要だ．

```python

langs = ['python', 'c', 'perl', 'go']

def enliven(word):
    return word.capitalize() + '!'

def edit_story(words, func):
    for word in words:
        print(func(word))

edit_story(langs, enliven)
```

```
Python!
C!
Perl!
Go!
```


ラムダ関数を使えば一行ですむ．

```python
langs = ['python', 'c', 'perl', 'go']
edit_story(langs, lambda word: word.capitalize() + '!')
```


##エラー処理とtry, except

```python
short_list = [1,2,3]
while True:
    value = input('Position [q to quit]? ')
    if value == 'q':
        break
    try:
        position = int(value)
        print(short_list[position])
    except IndexError as err:
        print('Bad index:', position)
    except Exception as other:
        print('Something else broke:', other)
```

```
Position [q to quit]? 1
2
Position [q to quit]? 0
1
Position [q to quit]? 2
3
Position [q to quit]? 3
Bad index: 3
Position [q to quit]? two
Something else broke:', invalid literal for ....
Position [q to quit]? q
```


## Python標準ライブラリ

### setdefault()とdefaultdict()による存在しないキーの処理


### Counter()による要素数の計算

### OrderDict()によるキー順のソート

### スタック＋キュー＝デック


### itertoolsによるコード構造の反復処理

### pprint()によるきれいな表示


# オブジェクトとクラス

## classによるクラスの定義

## 継承

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

## メソッドの追加

## superによる親への支援要請

## selfの自己弁護

## プロパティによる属性値の取得，設定

## 非公開属性のための名前のマングリング

## メソッドのタイプ