|
ホーム 戻る
"白石かずこ さん"の詩集「浮遊する母、都市から」 から。
てのひらにのせてあげるから こっちへ
むかうみちは そこでとぎれている
ひらり ひらひら 雪のふる夜は
ひらひら 雪よりひらひら ひいやり
ひらひら雪泣きやめず
ふり ふり ふりつづけ
２０１403022
改訂
http://www.pasteur.fr/formation/infobio/python/index.html
第６章 関数(function) メソッド 文字列メソッド
python研究の目的は、たとえば租税法入門、財務分析入門のような、税法、会計学分野のテキストをｐｙｔｈｏｎで記述すること。そのためには関数特にユーザ定義関数は重要項目。
（１）関数とは何か.
名前によって、計算を実行する、文。
カッコの中に引数parameterを持つ。
戻り値（ result.）を持つ。
名前で呼び出される。
関数：コ−ドをまとめて何回も繰り返して使用できるようにす
る。プログラムはいくつかの関数を使って作成する。
関数の種類：１ビルトイン関数：builtin function ＰＹＴＨＯＮで
あらかじめ用意されている組込関数：
２ ユーザ定義関数： ユーザが定義する関数。
関数の機能：値ｖａｌｕｅや変数ｖａｌｕａｂｌｅを引数ｐａｒａｍｅｔｅｒとし
て
、関数の実行結果を受け取るｒｅｔｕｒｎすることがで
きる。
ｒｅｔｕｒｎ文で関数から抜け出す。
関数:（）の中に仮引数を与えるとその引数に関連
する処理を返す（ｒｅｔｕｒｎ）。
関数名 ：function name
変数と同じ規則 で付ける。
関数名は関数オブジェクトへの参照となる。
命名規則（Ｊａｖａスタイルブック ｓｅ 社より）
１意味のある名前をつける
２ なじみのある名前をつける
３ 過度に長い名前は疑ってみる
４ 母音を省略しない
５ 頭字語は、先頭文字だけを大文字にする
例外がある
６ 大文字、小文字の違いだけの名前は使わない
関数はオブジェクト
関数名の変数にオブジェクトが格納される。
変数名（）で呼び出される。
>>> def square(x): Ｘ ＰＡＲＥＭＥＴＥＲ 仮引数
return x*x
>>> square(5) ５ ＡＲＧＵＭＥＮＴ 実引数
25
関数はオブジェクトとして関数を仮引数にすることができ
る
>>> def distance(x,y,func):
return func(x-y)
>>> distance(４,2,square) 仮引数に関数オブジェクト
を
使う
４
以下パスチュール研究所のｗｅｂより
1.1.4. Functions So far, we have used functions that perform a specific computation: len(), count(), lower(), find(), replace(), ... We can can define our own functions: >>> def welcome():
... print "Welcome to Paris"
... print "I hope you will enjoy it"
...
>>>
Notice the indented block of statements below
the def. This block corresponds to the statements
that will be executed when the function will be called.
Once the function is defined, you can use it:
>>> welcome()
Welcome to Paris
I hope you will enjoy it
>>>
Now, let's say that we want to welcome a specific person:
Welcome to Paris, Isabelle!
We could rewrite the function:
>>> def welcome():
... print "Welcome to Paris, Isabelle!"
... print "I hope you will enjoy it"
...
>>>
But what if we want to welcome Pascal? We are not going to write
another function, right? We can specify that our function will take a
parameter:
>>> def welcome(person):
... print "Welcome to Paris, ", person, "!"
... print "I hope you will enjoy it"
...
>>> welcome("Isabelle")
Welcome to Paris, Isabelle!
I hope you will enjoy it
>>> welcome("Pascal")
Welcome to Paris, Pascal!
I hope you will enjoy it
（２） 関数の定義書式.ユ−ザ定義関数
ユーザ定義関数の定義書式 def関数
ｄｅｆ name 仮引数 処理内容ｒｅｔｕｒｎ文等で構成。
def 関数名(仮引数リスト):
関数は、関数名に（）
をつけ、（）の中に引数を定義通りに
書く。
def statement ：関数であることの宣言。
関数の戻り値：返り値を返すには return 文を使用。
return value：ｐｙｔｈｏｎで扱うすべてのオブジェクト数値、
リスト等を返す。
複数の戻り値を返す
ｒｅｔｕｒｎ 戻り値、戻り値、戻り値、・・・・
関数の呼び出し： 関数名（引数、引数、引数、・・・・・）
call function
関数の戻り値の利用：
関数の戻り値を変数に代入。
変数 ＝ 関数（仮引数リスト）、仮引数
positional argument 引数の位置にマッチさせて、関
数を呼び出して、実引数を入力。
関数名 ｓｑｕａｒｅ、ｃｕｂｅ等 ｃｕｂｅ等。
-
仮引数、ｘ 等 実引数、６ 等
ｒｅｔｕｒｎ文 戻り値を返す。
ｐｒｉｎｔ関数 オブジェクトを表出する。
>>> x="野分して盥に雨を聞く夜哉 芭蕉"
>>> def haiku(): 引数なし
return ｘ
>>> haiku()
'野分して盥に雨を聞く夜哉 芭蕉'
:
扶養親族控除規定
扶養親族とは、その年の12月31日（納税者が年の中途で死亡し又は出国する場合は、その死亡又は出国の時）の現況で、次の四つの要件のすべてに当てはまる人です。
（注）出国とは、納税管理人の届出をしないで国内に住所及び居所を有しないこととなることをいいます。
(1) 配偶者以外の親族（6親等内の血族及び3親等内の姻族をいいます。）又は都道府県知事から養育を委託された児童(いわゆる里子)や市町村長から養護を委託された老人であること。
(2) 納税者と生計を一にしていること。
(3) 年間の合計所得金額が38万円以下であること。
(4) 青色申告者の事業専従者としてその年を通じて一度も給与の支払を受けていないこと又は白色申告者の事業専従者でないこと。
4 扶養控除額
控除額は、扶養親族の年齢、同居の有無等により次の表のとおりです。
 区分 |
控除額 |
| 一般の控除対象扶養親族（※1） |
38万円 |
|
>>> def 一般扶養親族控除(x):
return(x*380000)
>>> 一般扶養親族控除(3)
1140000
（３） 組込関数ｂｕｌｔｉｎ ｆｕｎｃｔｉｏｎ
ｐｙｔｈｏｎ言語にあらかじめ用意されている関数
ｌｅｎ関数
>>> a=["a","b","123"]
>>> len(a) ａはargument実引数
3 ３はＬＥＮ関数の戻り値という
（４）メソッド
メソッド：あるデータ型が専用に持っている関数のことをメソッド
という。
> address="tokyo,japan" address文字列型が専用に持
つsplitメソッド
>>> address.split() ｓｐｌｉｔメソッド
['tokyo,japan']
>>> address.split(",") カンマで要素を区切つて分離す
る。
['tokyo', 'japan']
（５）math functions import math
ｍａｔｈというモジュールに存在する関数
モジュール：利用可能なコードを集めてパッケージ化したもの。
何度も使う処理を自分でメソッドとして作る
作り方：求めたい結果は何か（戻り値）
利用できるデ−タはなにか（引数）
どんな処理をすればよいか（式）
メソッドの名前:機能をあらわす適切な名前を付ける
(６) 引数を使って計算する。
ｒａｔｅはキ−ワ−ド（名前） 付引数
>>> def taxPay(cost,rate=0.08): ｒａｔｅ名前を
付けて引数を渡す
return cost * (1.0 +rate)
>>> taxPay(1000000)
1080000.0
仮引数 ｌｏｗｅｒ ｕｐｐｅｒ
ｌｏｗｅｒからｕｐｐｅｒまでの数の累計を計算する。
def sum(lower,upper）
sum関数を宣言する
result = 0 初期値
while lower <=upper:
関数のボディ
result +=lower 引数の値変化
lower +=1
return result 結果表示
>>> sum(1,4) 関数呼び出し
10
>>> sum(50,100)
3825
複数の値を返すＰＹＴＨＯＮのreturn 文
>>> def p(a,b):
return a+b,a-b,a*b
>>> p(15,5)
(20, 10, 75)
>>> ａ=p(10,10)
>>> ａ
(20, 0, 100)
>>>
（７） 関数のpositional argument
1.位置依存引数（普通引数）ｐｏｓｉｔｉｏｎａｌ ａｒｇｕ
ｍｅｎｔ
置かれている位置にを基準としてマッチングする・
>>> def multi(x,y):
return x * y
>>> multi(5,6) ｘ、ｙと５，６がマッチする
30
>>> def div(x,y):
return x / y
>>> div(8,2)
4.0
>>> def 加算(x,y) 関数名 加算 ｘ、ｙ引数変数
return x + y ｒｅｔｕｒｎ文 ｘ＋ｙ戻り値
>>> a = 加算(7,9)
関数名加算を呼び出す 引数７，９
>>> a
16
（８） 関数のＫｅｙｗｏｒｄ argument
扶養控除額
控除額は、扶養親族の年齢、同居の有無等により次の表のとおりです。
| 区分 |
控除額 |
| 一般の控除対象扶養親族（※1） |
38万円 |
| 特定扶養親族（※2） |
63万円 |
| 老人扶養親族（※3） |
同居老親等以外の者 |
48万円 |
| 同居老親等（※4） |
58万円 |
※1 「控除対象扶養親族」とは、扶養親族のうち、その年12月31日現在の年齢が16歳以上の人をいいます。
※2 特定扶養親族とは、控除対象扶養親族のうち、その年12月31日現在の年齢が19歳以上23歳未満の人をいいます。
※3 老人扶養親族とは、控除対象扶養親族のうち、その年12月31日現在の年齢が70歳以上の人をいいます。
※4 同居老親等とは、老人扶養親族のうち、納税者又はその配偶者の直系の尊属（父母・祖父母など）で、納税者又はその配偶者と常に同居している人をいいます。
※5 同居老親等の「同居」については、病気の治療のため入院していることにより納税者等と別居している場合は、その期間が結果として1年以上といった長期にわたるような場合であっても、同居に該当するものとして取り扱って差し支えありません。ただし、老人ホーム等へ入所している場合には、その老人ホームが居所となり、同居しているとはいえません。
>>> def 扶養控除(f1,f2,f3,f4):
ff1=f1*380000
ff2=f2*630000
ff3=f3*480000
ff4=f4*580000
ff5=ff1+ff2+ff3+ff4
print("一般扶養控除額",ff1)
print("特定扶養控除",ff2)
print("非同居老親老人扶養控除",ff3)
print("同居老親老人扶養控除",ff4)
print("扶養控除合計",ff5)
>>> 扶養控除(3,1,1,1)
一般扶養控除額 1140000
特定扶養控除 630000
非同居老親老人扶養控除 480000
同居老親老人扶養控除 580000
扶養控除合計 2830000
>>> def addres(si="横浜市"):
ku=input("区>")
mati=input("町>")
tyo=input("丁目>")
ban=input("番地>")
return(si,ku,mati,tyo,banｚ＝１０
ｚ ｐａｒａｍｅｔｅｒ ｎａｍｅ
ｐｏｓｉｔｉｏｎａｌ ａｒｇｕｍｅｎｔの後に記入する。
>>> def 数(x,y,z=10):
デフォルト引数指定
return x,y,z
>>> 数(5,3)
(5, 3, 10)
>>> a = [10]
>>> def 数２(x=a): デフォルト引数指定
return x
>>> 数２()
[10]
>>> a.append(100)
>>> 数２()
[10, 100]
def hello(name): name:仮引数
return 'hello, ' + name + '!'
>>> hello('tobari') tobari実引数
'hello, tobari!'
>>> def 税法科目(x,y):
print('税理士試験に',x,y,'を選択した')
>>> 税法科目('所得税','相続税')
税理士試験に 所得税 相続税 を選択した
（９） 関数のドキュメンテ-ション文字列
-関数（クラスも）定義の最初の命令文が文字列の場合、その文字列は関連付けられたオブジェクトのための「ドキュメンテ-ション文字列」となる。インデントは他の定義中の命令文と一致させる。
>>>def square(x):
'calculates the square of number x .'
return x*x
>>> square(9)
81
>>> square.__doc__ ｄｏｃｓｔｒｉｎｇを呼び出す
'calculates the square of number x .'
>>> help(square)
.__doc__ docstring説明部分を表示
Help on function square in module __main__:
square(x)
calculates the square of number x .
helpは special built in functionである。
------------------------------------------------------------------------------------------
（１０） 関数のキーワード引数を使う
引数のデフォルト値
あらかじめ決まった値を持つ
呼び出し時に引数を指 定しない
デフォルト値を持つ引数は他
の引数の後ろにまとめて書く
明示的に引数に名前をつける
Ｋｅｙｗｏｒｄ argument
関数（キーワード = 引数値 、キーワード ＝引数
値・・・・・）
引数名= 値 とすると、順番にかかわらず、変数に直
接値を渡す。
si = '川崎市' ｓｉ デフォルト引数
>>> def addres(si="川崎市"):
ku =input("区>")
mati = input("町>")
tyo = input("丁目>")
ban = input("番地>")
print(si,ku,mati,tyo,ban)
>>> addres()
区>高津区
町>溝口
丁目>３
番地>８−２１
川崎市 高津区 溝口 ３ ８−２１
a = addres( )
関数の外側で利用する
>>> a
('川崎市', '高津区', '溝口', '３８−２１' )
>>> def addres(si="横浜市"):
ku=input("区>")
mati=input("町>")
tyo=input("丁目>")
ban=input("番地>")
return(si,ku,mati,tyo,ban)
>>> addres()
区>戸塚区
町>戸塚町
丁目>３丁目
番地>１０番地
('横浜市', '戸塚区', '戸塚町', '３丁目', '１０番地')
（１１）位置依存引数とキーワード引数を使う
関数（キーワード ＝引数値、キーワード ＝引数値・・・・）
キーワード引数、ｓｉ，ｋｕ
def 住所(ma,tyo,ban,si='川崎市',ku='高津区'):
ma=input 0 ｓｉ ｋｕ はキーワード引数
tyo=input('丁目>')
ban= input('番地>')
print(si,ku,ma,tyo,ban)
ｓｉ ｋｕは呼び出し順
ｍａ，ｔｙｏ，ｂａｎ引数設定
>>> 住所('ma','tyo','ban')
町名>溝口
丁目>３丁目
番地>３−８−２１
川崎市 高津区 溝口 ３丁目 ３−８−２１
（１２）可変数の位置依存引数を使う
ｄｅｆ 関数（位置依存引数リスト、＊位置依
存可変引数）
def 平均( *inputs): ＊位置依存可変引数
d=float(sum(inputs))/ float(len(inputs))
print (d)
>>> 平均(45,34,67,98,23,56)
53.8333333333
..（１３）可変数のキーワード引数を使う
辞書型の可変長引数
ｄｅｆ 関数（位置依存引数リスト、＊＊キーワード可変引数）
>>> def 蔵書目録(aut,tit,yea,co,jo,ob,**bib):
print('著者 =',aut)
print('書名 = ', tit)
print('発行年=',yea)
print('出版社',co)
print('状態',jo)
print('帯',ob)
for (k,v) in bib.items():
print (k ,'=',v)
>>> 蔵書目録("戸張道也","電子書籍","平成２３年","田園都市社","なみ","なし")
著者 = 戸張道也
書名 = 電子書籍
発行年= 平成２３年
出版社 田園都市社
状態 なみ
帯 なし
（１４）位置依存引数とキーワード引数と未定義引数〔可
変引数）を使う
>> def 住所(n,*ku,si='川崎市'):
ｋｕにはタプルとして代入される
return n,si,ku
>>> 住所(1,'高津区')
(1, '川崎市', ('高津区',))
>>> 住所(2,"高津区","溝口","３丁目","3-8-21")
(2, '川崎市', ('高津区', '溝口', '３丁目', '3-8-21'))
関数のドキュメンテーション
>>> def siranosay():
"""シラノの最後の言葉「これがおれの心意
気だ」"""
print("これがおれの心意気だ")
>>> siranosay()
これがおれの心意気だ
>>> siranosay.__doc__ 関数のドキュメンテー
ションにアクセスする。
'シラノの最後の言葉「これがおれの心意気だ」'
>>> help(siranosay) 関数の使い方にアクセス
Help on function siranosay in module __main__:
------------------------------------------------------------------------------------------
>>> def 相続税基礎控除(法定相続人数):
ｆｕｎｃｔｉｏｎ ｄｅｃｌａｒａｔｉｏｎ
return 法定相続人数
*10000000+50000000
>>> 相続税基礎控除(3)
ｆｕｎｃｔｉｏｎ ｃａｌｌｉｎｇ
80000000
（１5 ）""" """で説明文をつけると
def 基礎控除(n):
"""相続人数を引数入力・相続税基礎控除算"""
return int(n) * 1000 + 5000
>>> 基礎控除(3)
8000
説明文にアクセスする
>>> 基礎控除.__doc__
'相続人数を引数入力・相続税基礎控除算出'
（１6）グローバル変数とローカル変数
ロ−カル変数：関数のブロック内で代入が行われる変数
関数の外で使うことはできない
ローカル変数の置かれている場所：名前空間
簡単な例
>>> x = 1 グローバル変数
>>> def test():
x = 2
ｘはローカル変数：関数の中で変数へ代入されている。
print(x)
>>> test()
2
>>> def a():
x = "python” ｘはローカル変数
print(x)
>>> a()
python
>>> x = "ruby" ｘはグローバル変数
>>> x
'ruby'
関数内でグローバル変数を使うときは、ｇｌｏｂａｌ宣言を使う。
>>> def j():
global x
ｇｌｏｂａｌ宣言：必要以外使わないほうがよい。
x = "python"
print(x)
>>> x ="ruby"
>>> j()
python ｘの内容は変わらない
>>> x
'python' 同上
>>> x = 1
>>> def test ():
global x ｇｌｏｂａｌ宣言
x += 1
print (x)
>>> test()
2
>>> test()
3
（１7）関数型プログラミング 内包表記
関数型プログラミング：関数の組み合わせによって
ある処理を関数に、さらに小さな関数に分解して抽象化し、問題解決の適用範囲を広げる。
リスト内包表記を使っている。
>>> [x**2 for x in [1,2,3]]
[1, 4, 9]
ｍａｐ（）
ｍａｐ（）関数はシ−ケンスの各要素に対して、関数を呼び出して、
その戻り値のリストを返す。
map(func,a)関数は関数ｆａｎｃをａの各要素に適用し新しいリストを返す。この場合ｍａｐ（）に与えらる引数をひとつだけ要求するものでなければならない。
>>> a=[1,2,3,4,5,6]
>>> def foo(x):
return 3*x
>>> b=map(foo,a)
>>> list(b)
[3, 6, 9, 12, 15, 18]
匿名関数ｌａｍｂｄａを使えば
>>> b=map(lambda x: 3*x ,a)
>>> list(b)
[3, 6, 9, 12, 15, 18]
>>> list(map(lambda x: x**2,[1,2,3]))
[1, 4, 9]
>>> a=map((lambda x : x + 2 ),[0,1,2,3])
>>> list (a)
[2, 3, 4, 5]
>>> b = map(lambda x : x**2,range(5))
>>> list(b)
[0, 1, 4, 9, 16]
>>> [x+2 for x in range(5)]
[2, 3, 4, 5, 6]
>>> [x **2 for x in range(5)]
[0, 1, 4, 9, 16]
>>> c = map(lambda x ,y:(x+y,x-y),[1,3,5],[2,4,6])
>>> list(c)
[(3, -1), (7, -1), (11, -1)]
>>> a = ['a','b','c']
>>> list(map(f,a))
['a?', 'b?', 'c?']
>>> b = ['A','B','C']
>>> list(map(f2,b,a))
>>> ['Aa', 'Bb', 'Cc']
>>> def f(x):
return x * 2
>>> lst=[1,2,3]
>>> list(map(f,lst))
[2, 4, 6]
>>> def cub(x):return x*x*x
>>> b=map(cub,range(1,11))
>>> list(b)
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
>>> seq = range(8)
>>> def add(x,y):return x+y
>>> list(map(add,seq,seq))
[0, 2, 4, 6, 8, 10, 12, 14]
>>> list(map(lambda x,y:(x+y,x-y),[1,3,5],[2,4,6]))
[(3, -1), (7, -1), (11, -1)]
lampda()
lampda args (コンマで区切った引数のリスト） ： ｅｘｐｒｅｓｓｉｏｎ（引数を呼び出す式）
ｆｏｒ、ｗｈｉｌｅのような式ではない文は使えない。
>>> a=lambda x,y :x+y
>>> print (a(2,3))
5
filter() lambda() reduce() ｚｉｐ（）
filter()
（１９）リストの要素を抽出 : filter
例えば、 3 より大きい要素を得る場合、
a=(filter(lambda x: x>3, [1,2,3,4,5,6,7]))
>>> list(a)
[4, 5, 6, 7]
>>> a= map(lambda x: x**2, filter(lambda x: x [2,3,4,5]))
>>> list(a)
[16, 25]
>>> list(filter(lambda x: x > 0 ,[1,-
２,3,-４]))
１，３
The filter() function can always be replaced with a generater expression
>>> [x for x in [1,-2,3,-4] if x > 0 ]
[1, 3]
（18）reduce（）関数は単一の値を返す。関数の二つの引数を呼び出し、その結果と次の要素をとり、またこの結果と次の要素をとるということを繰り返す。
>>> from functools import reduce
>>> def add(x,y):return x + y
>>> reduce(add,range(1,11))
55
>>> from functools import reduce
>>> reduce(lambda x ,y: x * y ,[1,2,3,4,5])
120
>>> def sum(seq):
def add(x,y): return x+y
return reduce(add,seq,0)
>>> sum(range(1,11))
55
>>> sum([])
0
今はＳＵＭ（）が関数として用意されているので、次のようにする。
>>> a=range(1,11)
>>> sum(a)
55
リスト全体に合計、総乗の計算をする。
from functools import reduce
>>> l=[1,2,3,4,5]
>>> print(reduce(lambda a,b:a+b,l))
15
>>> print(sum(l))
15
>>> print (reduce(lambda a,b: a*b ,l))
120
>>>
>>> print (reduce(lambda a,b :a+[b*2],l,[]))
[2, 4, 6, 8, 10]
空のリストを初期値とし、演算適用後、リスト完成。
３より大きい数値を選ぶ
>>> l=[1,2,3,4,5]
>>> print (reduce(lambda a,b: a+[b] if b > 3 else [],l,[]))
[4, 5]
（19）リストの内包表記
リストの内包表記ＬＩＳＴ ＣＯＭＰＲＥＨＥＮＳＩＯＮは リストの生成をＭＡＰ、ＦＩＬＴＥＲ、ＬＡＭＢＤＡを使わずに結果を求める。
１．簡単な例
def is_even(x): 偶数を返す関数定義
return (x % 2) == 0
>>> list(filter(is_even,range(10)))
リスト[0:10]から偶数リス ト を返す
[0, 2, 4, 6, 8]
------------------------------------------------------------------------------------------
個々の要素について同じことをする
ｆｏｒループ、ｍａｐ関数,lambda ,りスト内包表記
>>> counter =[1,2,3,4,5]
>>> update =[ ]
>>> for x in counter :
update.append(x+100)
>>> update
[101, 102, 103, 104, 105]
>>> def inc(x):ｒeturｎ x+100
>>> map(inc,counter）
ｍａｐビルトイン関数
<map object at 0x014928D0>
>>> list(map(inc,counter))
[101, 102, 103, 104, 105]
>>> a=map((lambda x: x+ 50),counter)
>>> a
<map object at 0x01492D30>
>>> list(a)
[51, 52, 53, 54, 55]
>>> [x**2 for x in range(10)]
りスト内包表記
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> a=map((lambda x:x**2),range(10))
>>> list(a)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Anonymous Function and lambda
（20）無名関数 ラムダ
lamda [arg1,arg2, ....argN]:expression
名前の宣言がない。
引数は任意で式の一部def で定義すると冗長になる短い
関数を無名関数ｌｍｂｄａを使って定義する。
無名関数の定義は 'lambda' に続けて引数をカンマで区切って書き、 コロンの後に帰り値を書く。一行で書けるものにしか使えないので単純なものしか定義しない。
>>> lamF = lambda x : x * x
>>> lamF(100)
10000
.
>>> def add(x,y) : return x + y
>>> add(3,5)
8
>>> lambda x, y: x + y
<function <lambda> at 0x00F7B198>
>>> a = lambda x,y : x + y
>>> a
<function <lambda> at 0x00F7B270>
>>> a(3,5)
8
>>> a= lambda x, y= 2 : x + y
>>> a(3)
5
>>> a(0)
2
（21）ｚｉｐ関数
複数のシーケンス型のオブジェクトを指定し、各オブジェクトの同じインデックスの要素をタプル型のオブジェクトにして、タプル型のオブジェクトを要素とするリストを返す方法。 zip([sequence1, sequence2, ...])
シーケンス型の要素数が異なる場合は一番少ない要素数のリストになる。
>>> zip ([1,3,5],[2,4,6])
<zip object at 0x00F78DF0>
>>> list(zip ([1,3,5],[2,4,6]))
[(1, 2), (3, 4), (5, 6)]
reduce() 関数
>>> from functools import reduce
>>> print("the total is :", reduce((lambda x, y : x +y ),range(5)))
（22）概念の説明
サブルーチン：プログラムの部分、手続き。
プログラムの一部を切り離したも
の。引数（入力）を得て、何らかの、手続
きを実行して、戻り値（出力）を返すという
全体として一つの関数として機能する。
サブルーチン：関数：ｆｕｎｃｔｉｏｎ：機能：ある
プログラムの一部を何回も使いまわ
す。
スコープ：変数の名前が及ぶ範囲
ビルトインスコープ：ｐｙｔｈｏｎの関数の利用
範囲
グローバルスコープ：モジュールファイルに
属する名前空間。
モジュール空間に制約
される。モジュールの関数から参
照できる。
ローカルスコープ： 関数のようなブロックの
名前空間に属する名前空間。名前が
同じでもローカルスコープの変数に
対する変更はグローバル変数に影
響しない。
あらかじめ組みこまれた機能：関
数、メソッドを使う。
関数：名前（引数、...）
メソッド：名前.名前(引数,...)
y[i].split(','),
これはsplit(y[i],',')の関数の呼び出
しと同じ意味。 ' , y[i]について ' ・ 'という機能
を使う。
'\t'.join(z)文字列 '\t' にｚという引
数をつけてｊｏｉｎ()を呼び出す
メソッド：手続きをモジュール化して再利用する仕組
み：クラスの中に書いた関数を普通の関数と区
別してメソッドと呼ぶ：普通の関数とは違って、メ
ソッドの第一引数には特別の意味があって、こ
のメソッドが呼び出されたときのインスタンスが
渡ってくる：この引数はどんな名前で定義しても
よいが、慣習的にｓｅｌｆという名前をつけること
が強く推奨されている
メソッドﾞ：あるオブジェクトが別のオブジェクトにメッセ
ージを渡す。受け取ったオブジェクトがメッセ
対応する操作をする。この操作をメソッドとい
う。オブジェクトを扱うための手続き。
メソッドに渡す情報を引数という。
メソッド：クラス専属のファンクションメソッドは名前.名
前（引数,・・・）。
動詞のようなもの：関数のようなもの
オブジェクト：対象物：名詞のようなもの。文字列、数
値、時刻など様々なデータすべてのメソ
ッドにはオブジェクトが必要である。
プログラム全体もオブジェクトである。
（２３）例
>>> def 挨拶(お早う,今日は,今晩は,さようなら):
print("お早う ！" * お早う)
print("今日は ！" *今日は)
print("今晩は ！" *今晩は)
print("さようなら ！" *さようなら)
(おはよう、今日は、今晩は、さようなら):引数
print(*お早う):お早うはローカル変数
>>> 挨拶(5,3,2,1)
呼び出された関数挨拶の引数（５）ローカル変数 お早う に代入される
お早う ！お早う ！お早う ！お早う ！お早う ！
今日は ！今日は ！今日は ！
今晩は ！今晩は ！
さようなら ！
引数の順番は重要
キーワード指定：名前を指定して引数を渡す。変数に直接値を渡す
>>> 挨拶(お早う=2,今日は=1,今晩は=3,さようなら=1)
お早う ！お早う ！
今日は ！
今晩は ！今晩は ！今晩は ！
さようなら ！
金利計算 １年金融債 割引率表示と利回り表示
>>> def 割引率(r,g=100):
ｒ：年割引率 ｇ：額面
return (r /g) * 100
>>> 割引率(3.52)
3.52
>>> def 利回り(r,g):
ｒ：年割引率 ｇ：額面
g=100-r
return (r / g)*100
>>> 利回り(3.52,100)
3.6484245439469321
>>>
公的年金に係る雑所得の速算表konen()関数を
つくる。
(a)年齢６５歳未満
def konen():
収入金額 = input('収入金額>')
if int(収入金額) < 1300000 :
課税公的年金 = int(収入金額) * 1 -
700000
print('課税公的年金',int( 課税公的年金))
elif int(収入金額) < 4100000:
課税公的年金 = int(収入金額) * 0.75
-３７５０００
print('課税公的年金',int(課税公的年金))
elif int(収入金額) < 7700000:
課税公的年金 = int(収入金額) * 0.85 -
785000
print('課税公的年金',int(課税公的年金))
else :
課税公的年金 = int(収入金額) * 0.95 -
1555000
print('課税公的年金',int(課税公的年金))
>>> konen()
収入金額 > 5500000
課税公的年金 3890000
（b)年齢６５歳以上
def konen2():
収入金額 = input('収入金額>')
if int(収入金額) < 3300000 :
課税公的年金 = int(収入金額) * 1 -
1200000
print('課税公的年金',int( 課税公的年金))
elif int(収入金額) < 4100000:
課税公的年金 = int(収入金額) * 0.75 -
375000
print('課税公的年金',int(課税公的年金))
elif int(収入金額) < 7700000:
課税公的年金 = int(収入金額) * 0.85 -
785000
print('課税公的年金',int(課税公的年金))
else :
課税公的年金 = int(収入金額) * 0.95 -
1555000
print('課税公的年金',int(課税公的年金))
>>> konen2()
収入金額 > 3500000
課税公的年金 2250000
問題の解決には、小さいプログラムを作ってからまとめる法が楽である。ｐｙｔｈｏｎはインデントが基本要素なので、ブロック単位で作る。
変数名とファイル名に漢字を使用した。ｐｙｔｈｏｎ３．０税法や財務分析の場合、ローマ字では内容を把握しにくいので漢字処理ができるのは大変便利。
ｉｄｌｅエディター、ｔｅｒａｐａｄ，ｐｙｓｃｒｏｐｔｅｒ等のエディターを使う。
windowsはｘｐプロ以上
漢字入力でｉｎｄｅｎｔエラーが出ることがあるので、初め英字で作成し、正常に実行できることを確認してから、漢字になおすとうまくゆく。
生命保険料控除の計算
def sei_ko(x):
if x <= 25000 :
return x
elif x <= 50000 :
return int(round(x / 2 + 12500))
elif x <= 100000 :
return int(round( x / 4 + 25000))
else :
return 50000
>>> sei_ko(57697)
39424
>>> sei_ko(112875)
50000
ｒａｎｇｅ関数
>>> range(100,105)
[100, 101, 102, 103, 104]
>>> range('101','105')
数値のみを使う。 文字はエラーとなる。
ｄｅｆ 定義
>>> def number(x, y, z):
menseki = (x + y) * z / 2
台形の面積
return menseki
>>> number(3,4,6)
<引数3,4,6複数
21
------------------------------------------------------------------------------------------
>>> def times(x, y):
関数オブジェクト作成： ｔｉｍｅｓ：関数
名
return x * y
ボデイ部分：呼び出されると実行
>>> times(2,4)
呼び出し：関数名（）：引数（オブジェクト）指定：
数に代入される
8
>>> x= times(3.14,4)
戻り値を変数に代入して利用する場合
>>> x
12.56
>>> times('ni',4)
文字列を繰り返す
'nininini'
------------------------------------------------------------------------------------------
>>> def sum(n1 = 0, n2 = 0, n3 = 0) :
return n1 + n2 + n3
>>> print( sum(2,5,7))
14
>>> print （sum(3,8))
11
>>> print( sum(4))
4
>>> print( sum())
0
------------------------------------------------------------------------------------------
>>> def digits(k = 0,h = 0,d = 0,n = 0) :
キーワード引数
return k * 1000 + h * 100 + d * 10 + n
>>> print digits(5,8,4,3)
5843
>>> print digits(k = 2, d = 9)
2090
>>> print digits(3 ,n = 6)
引数が指定されないとき最初の
引数に代入される
3006
---------------------------------------------
>>> def muladd(a,ｂ） 複数の値を返す
return a * b, a + b
>>> print( muladd(3,2))
(6, 5)
複数の戻り値タプルにまと
めている
------------------------------------------------------------------------------------------
>>> a,b,c = [3,2,1]
リストの３つの要素を３つの
変
数に同時に代入できる
>>> print( a)
3
>> print (c)
1
>>> def times2(n) :
n *= 2 . ｎ内部変数
print ("inside", n)
>>> n = 3
>>> times2(n)
inside 6
関数のなかのローカル変数の値
>>> n = 3
>>> print "outside:", n
グローバル変数には影響がない
outside: 3
>>>
>>> def times2(a) :
global n
グローバル宣言をしたので、外部の変
数にアクセスできる
>>> n = 3 ｎはグローバル変数
>>> times2(n)
inside 6
>>> print ("outside", n)
outside 6
ファンクション内部の変数ｎが外部の変
数ｎと同じになる：トラブル原因：実際に
は使わないこと。
>>> def changelist(l) : ｌは小文字のエル
l[3] = 3
>>> alist = [1,2,3,4,5]
>>> print ("before:", alist)
before: [1, 2, 3, 4, 5]
>>> changelist(alist)
>>> print ("after:", alist)
after: [1, 2, 3, 3, 5]
引数として与えたリストの内容が変更されて
いる。リストを引数として渡すと「ポインタ」が
変更される。要素がリストの場合だけ内容が変
更できる。
---------------------------------------------
>>> def sanjyo(x ） ｘは仮引数 数の名前部分
return x **3 関数の本体
>>> print (sanjyo(3))
27
------------------------------------------------------------------------------------------
>>> def even_odd(x):
if x % 2 == 0:
print( x , ' is even.')
else:
print( x, ' is odd.')
>>> even_odd(33)
33 is odd.
>>> even_odd(22)
22 is even.
------------------------------------------------------------------------------------------
>>> def sum(data) ｄａｔａは仮引数
total = 0
for x in data:
total = total + x
return total
>>> print( sum([1,2,3])) 1,2.３は実引数
6
------------------------------------------------------------------------------------------
>>> def func(x):
ｘ仮引数、局所変数、ｆｕｎｃの専用変数
x = x + 1
print ('func: = ', x)
>>> x ＝１０ メインプログラム
>>> y = 10
>>> func(y)
func: = 11
>>> print (x, y)
メインプログラムのｘ、ｙの値は変わらない
10 10
メソッドとは
(24)メソッドを使う
print( ' to be or not tobe')
to be or not tobe
この場合のprintメソッドのオブジェクトはプログラム自体。
1・インスタンスメソッドを使う
>>> "10,20,30,40".split(",")
['10', '20', '30', '40'] リストのインデックスを返す
>>> [1,2,3,4,5,6].index(3) リストの３のインデックスは０から数えて２
2 インデクスを示す
2．メソッドの定義
>>> def hello(): メソッドの名前
(print（ "hello python"） ) メソッドの本体
>>> hello() メソッドを呼び出す
hello python
>>>
>>> def volume(x, y, z): 仮引数 ｘ ｙ ｚ 名前
return x * y * z メソッド本体
>>> print( volume(2,3,4) ) 実引数２，３，４
24
>>> print volume(10,20,30)
6000
>>> def area(x, y, z):
xy = x * y
yz = y * z
zx = z * x
return (xy + yz + zx) * 2
>>> print (area(2,3,4))
52
>>> print(area(10,20,30))
2200
>>> def sum(x, y):
x + y
print( x + y)
>>> sum(45,87)
132
>>> def diff(x, y):
i = x - y
print (i)
>>> diff(54,23)
31
メソッドの形式：オブジェクト名.メソッド名（引数・・・）
オブジェクト＞レシーバ＞オブジェクトにメソッドを送る＞オブジェクトはメッセージを受け取る＞引数とともにメッセージを送る
1．メソッド特選
（１）ｐｏｗ（） 累乗算
>>> y = 0
>>> val = pow(x, y)
>>> x = 2
>>> for y in range(0,11):
print (pow(x, y))
1 ２の０乗は１
2
4
8
16
32
64
128
256
512
1024
>>>
（２）sys dir （__ builtins__)組み込み関数のリストを表示
module:a file that contains a collection of related function
>>> import sys ｓｙｓモジュールを呼び出す
sys:sys module object
>>> print (dir(__builtins__))
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', ,
.........
（３） さらなる演算メソッド
>>> print (5 **0.5) ＊＊0.５は平方根をもとめる。
2.2360679775
>>> print (7 / 3) /では、剰余は出力されない。
２
>>> print (7 % 3) 剰余が出力。
1
>>> 365 / 7
52
>>> print (365 % 7) 一年が５２週間と１日
1
>>> print (abs(5 - 2)) abs()は絶対値を返す。
3
>>> print( abs(2 - 5))
3
>>> math.sqrt(5)
2.2360679774997898 5の平方根を出力する。
モジュ−ルのインポ−ト
多様な機能グル−プでまとまったモジュ−ルを利
用する。
>>> import math mathモジュール
>>> print (math.pi) 円周率
3.14159265359
>>> angle=45.0 * math.pi / 180 ４５度をラジアンに変換
>>> print (math.sin(angle)) サイン関数
0.707106781187
>>> import math import:statement
>>> degree=45 degree=45:assignment statement
degree:variable name
>>> radians=degree/360*2*math.pi radians:expression
>>> math.sin(radians) math:module
0.70710678118654746
>>> math.sqrt(2)/2.0
0.70710678118654757
（12）文字列 メソッド 関数
split()文字列メソッド
>>> y = ['a, b, c', 'd, e, f', 'g, h, i']
>>> y[0]
'a,b,c'
>>> y[0].split(',')
['a', 'b', 'c']
>>> y[1]
'
d,e,f'
>>> y[1].split(',')
['d', 'e', 'f']
ｊｏｉｎ（ｓｅｑ）文字列メソッド 連結したｓｅｑを返す
>>> s = ['戸張', '田中', '山田']
>>> ch = ':'
>>> ch.join(s)
'戸張:田中:山田'
>>> ';'.join(s)
'戸張;田中;山田' 変数を使わずに
>>> s = ' ：ok:'
>>> t=s.join('qwerty')
>>> print (t)
q:ok:w:ok:e:ok:r:ok:t:ok:y
文字列メソッド特選
（a) input:("prompt'') :
標準出力にプロンプト（"＞等"）を書き出し、標準入力から一行を読み取りその行を文字列として返す。
>>> print (input("何か入力してください.。＞"))
>何か入力してください。 かっこ内の文字列をそのまま、出
力
しユーザの入力を待つ。
(b)メソッド
>>> def say_goodnight(name): < メソッドの名前
return 'good night' + name <メソッドの本体
>>> print (say_goodnight (" Mori Hnae san"))
good night Mori Hnae san
>>>
(c)ｅｖａｌ関数 文字列でｐｙｔｈｏｎの式を受け取って実行する
>>> eval('"a,b,c".split(",")')
['a', 'b', 'c']
>>> ｘ ＝ １
>>> eval('x + 1')
2
長い単一文の書き方
プログラムの単一文は原則一行単位
一行８０文字が推奨されている
復習 関数 関数型プログラミング メソッド
比較的簡明な例示。
触目
ひとりで生き、この世を観
この世の雨の音をきき
そしてまた死んで行ったとしても
何者をこの世に残さなかったとしても
それだけで沢山ではないか
その片鱗をかがやかせただけで
蝶はわが眼から失われて行ったではないか
百田宗治
関数とは
あらかじめ用意されている組込関数と自分で作る関数
と２種類ある。利用の方法は全く同じである.
名前（引数）の形式で書かれる
ｌｅｎ（ｘ） 引数Ｘについて何かをする ｌｅｎは組み込み関数
>>> s=[1,2,3,4,5,6]
>>> len(s)
6
関数のメリットは
１．繰り返し作業をコード化する
２．処理の内容が短縮される
３．処理の変更が容易になる。
自分で関数を作る
defステートメント
>>> def hello():
print ('hello python')
>>> hello()
hello python
6
２。メソッドとは
名前。名前（引数）のような形式をとる。データ型（オブジェクト）が特
別に
持っている命令のこと。
オブジェクト ドット メソッドの順で書く
>>> address="mizonokuti,takatuku,kawasakisi,kanagawaken,japan"
>>> address.split(","）
['mizonokuti', 'takatuku', 'kawasakisi', 'kanagawaken', 'japan']
>>> 'hello'.upper()
'HELLO'
３。 関数を作る
（１）点数評価
def hyoka() :
x=input('点数>')
if int(x)>=1 and int(x)<=50 :
print('低い')
elif int(x)>50 and int(x)<=75 :
print('中間')
else :
print('高い'):
>>> hyoka()
点数>65
中間
>>> hyoka()
点数>78
高い
>>> hyoka()
点数>38
低い
（２）足し算
def purasu(x,y):
print(x+y)
purasu(23,26)
49
（）の中に仮引数、実引数、空が入る
引数
（３）回数
say_moo() 鳴く回数を引数として加えるに
は、どうするか
考える。
def saymo() :
for i in range(3):
print ('モ-')
>>> saymo()
モー
モー
モー
、 演算子を使用して１行に出力
>>> def saymo():
for i in range (3) :
print( 'モー',)
>>> saymoo()
モー モー モー
i in range(3):はメソッドを実行するときに与え
られた引数を（メソッドの中から）指し示すための
変数。引数は３。
オブジェクトｓａｙｍｏが名詞で、メソッドｐｒｉｎｔ（’
モー’）が
動詞であるならば、引数for i in range(3)は副
詞。
（４）土地建物長期譲渡で取得する資金額を
計算する関数。
def jyoto () :
jyoto=input('譲渡金額>')
print('取得価額は減価償却後の金額で
す。')
syutoku=input('取得金額>')
print('改良費も償却後の金額です。')
kairyohi=input('改良費>')
print('経費は仲介料等の譲渡費用です。')
keihi=input('譲渡経費')
kazei=int(jyoto)-int(syutoku)-int(kairyohi)-int(keihi)
print ('税は長期譲渡の場合の国・地方税
の概算で
す。')
zei=int(kazei)*0.2
sikin=int(jyoto)-int(zei)
print('課税対象',kazei)
print('国・地方税＝',zei )
print('資金増加',sikin)
>>> jyoto()
譲渡金額>30000000
取得価額は減価償却後の金額です。
取得金額>2000000
改良費も償却後の金額です。
改良費>500000
経費は仲介料等の譲渡費用です。
譲渡経費1500000
税は長期譲渡の場合の国・地方税の概算です。
課税対象 26000000
国・地方税＝ 5200000.0
譲渡金額資金増加
24800000
抽象化の例
>>> def hello(name):
return'hello, '+name+'!'
>>> print(hello("world"))
hello, world!
>>> print(hello("taro"))
hello, taro!
引数nameで抽象化
（５）局所変数 Local variable
def duble_times():
num=0
num=input('>')
num=int(num)
num_times2=int(num)*2
print (num,'の２倍は',num_times2)
>>> duble_times()
>34
34 の２倍は 68
変数１ numと 変数２ num_times_2 と二
っあります。
この二つは局所変数。メソッドの内部に
のみ存在する関数。
>>>duble_times()
>56
56の２倍は 112
>>> print( num_times_2)
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
print num_times_2
NameError: name 'num_times_2' is not
defined
変数num_times_2を外部から使用できません・
メソッドの中 でのみ有効。
（６） 返り値
が呼んだコードに返
す。
print 関数はプログラムが画面に対して情報を出
力する。
>>> def say_moo() :
print （'モー’）
>>> say_moo()
モー
>>> print（ say_moo(）） 、
モー
None ＜ print が出力したモノ、。printはいつ
もNoneを返す。
＜文字列を返すようにしたければ、それをメソッドに適用
>>> def say_moo():
print （'モー’）
print （'yellow ｏｒａｎｇｅ’）
>>> say_moo()
モー
yellow ｏｒａｎｇｅ
（７） ｒｅｔｕｒｎ文を使う.。
return文は関数の中で使い、カッコを使わな
いで関数の 外に受け渡したいデータをそのまま記述。
>>> def f(a,b):
c = a +b
return c
>>> f(7,8)
15
>>> def times(x,y): ＜変数オブジェクトを作成し、関数
名に代入
ｒeturn x*y ＜呼び出された場合に実行さ
れるボ
ディ
>>> times(34,67) ＜カッコ内に引数を指定し、呼
び出す。
2278
def food():
name=input('名前入力＞')
if name=='鈴木':
return ('おもち')
if name=='山田' :
return ('ベーコン')
>>> food()
名前入力＞鈴木
'おもち'
>>> food()
名前入力＞山田
'ベーコン'
（８）ｒｅｔｕｒｎ文を使わない。
def food():
name=input('名前入力＞')
if name=='鈴木':
print ('おもち')
if name=='山田' :
print ('ベーコン')
>>> food()
名前入力＞鈴木
'おもち'
>>> food()
名前入力＞山田
'ベーコン'
(８)同じコードの繰り返す例：
print (ｂｏｏｋ＿ｋｅｅｐｉｎg)
(クリス著・はじめてのプログラミング参照）
（９）関数で上記のコードを修正する
これで自分のメソッドを作ることを学だの
で、ここで心理学の実験プログラムを修正。
あいさつ文の関数
def aisatu() :
print（ '今日は、私の実験のためにお時間をとって、’）
print（ 'いただき、ありがとうございます。この実験
は、’）
print（ '人々が日本料理に対してどう感じているか’）
print （'に関するものです。日本料理について考え’）
print （'すべての質問に対して、ｙｅｓかｎｏかで正直
に’）
print（ '答えてください。この実験は簿記学習とは関
係’）
print （'ありません。’）
aisatu（）と入力すると、あいさつ文が画面に出力されます。
質問文
>>> q1 ='天ぷら'
>>> q2 ='フグ'
>>> q3 = '簿記学習はすきですか？'
>>> q4 = '焼き肉'
>>> q5 = 'そば'
>>> q6 = 'すし'
>>> q7 = 'うなぎ'
>>> q10 ='はお好きですか'
>>>ｐｒｉｎｔ（ｑ１＋ｑ１０）
天ぷらはお好きですか
質問ブロックの関数。
>>> def ask():
good_answer = False
while (not good_answer):
reply = input('"yes","no">')
if (reply =='yes'or reply =='no'):
good_answer= True
elif reply =='yes' :
answer = True
elif reply =='no':
answer = False
else : print（ 'yesかnoでお答えください’）
>>> ask()
"yes","no">no
>>> ask()
"yes","no">yes
>>> ask()
"yes","no">nonono
yesかnoでお答えください
"yes","no">
実験の目的を明かす文。
>>> def db():
print （'デブリーフィング’）
print（ 'この実験へのご協力を感謝します。実は、この実’）
print （'験は日本料理とは何の関係もありません。’）
print（ 'この実験は簿記学習に関する実験だっ’）
print （'たのです。日本料理はより正直にこたえら’）
print （'れるよう、あなたのガードをはずすために聞いた’）
print （'にすぎません。本当に有難うございました。’）
メッソドと関数との用語の使い方について認識 する
. メソッド
データ型（オブジェクト）が特別に持っている命令のこと。
オブジェクト ドット メソッドの順で書く
>>> address="mizonokuti,takatuku,kawasakisi,kanagawaken,japan"
>>> address.split(","）
['mizonokuti', 'takatuku', 'kawasakisi', 'kanagawaken', 'japan']
（１２）関数に説明文を加える
>>> def jyoto():
jyoto=input("譲渡金額>")
"譲渡金額は減価償却した後の金額です"
syutoku=input("取得金額＞")
kairyohi=input("改良費＞")
"改良費も償却した後の金額です"
keihi=input("経費＞")
"仲介料等の経費です"
kazei=int(jyoto)-int(syutoku)-int(kairyohi)-int(keihi)
zei=int(kazei)*0.2
"税は国及び地方税の概算額です"
"資金は譲渡の結果得られる資金額です"
sikin=int(jyoto)-int(zei)
print("譲渡金額＝" ,jyoto)
print("税＝ ",zei)
print("取得資金＝ ",sikin)
>>> jyoto()
譲渡金額>10000000
取得金額＞5000000
改良費＞500000
経費＞300000
譲渡金額＝ 10000000
税＝ 840000.0
取得資金＝ 9160000
,
ホーム 戻る
ホーム 戻る
ホーム 戻る
|