ホーム     戻る
 


ひとりで生き、この世を観

この世の雨の音をきき

そしてまた死んで行ったとしても

何者をこの世に残さなかったとしても

それだけで沢山ではないか

その片鱗をかがやかせただけで

蝶はわが眼から失われて行ったではないか


 百田宗治
第9章 関数 関数型プログラミング メソッド    

 
改訂2011/11/13

 


 

Function

Functions are named sequences of statements that execute some task.

We have already used functions, such as:

>>> type('GAATTC')
<type 'str'>
>>> len(cds)
852
      

For example len is a function that calculates the length of things and we asked here for the length of our DNA sequence cds.

Function call

Function calls are statements that execute or call a function. The Python syntax of function calls is the function name followed by a comma separated list of arguments inclosed into parentheses. Even if a function does not take any argument the parentheses are necessary.

Differences between function calls and variables.  As variable names, function names are stored in a namespace with a reference to their corresponding sequence of statements. When they are called, their name is searched in the namespace and the reference to their sequence of statements is returned. The procedure is the same as for variable names. But unlike them, the following parentheses indicate that the returned value is a sequence of statements that has to be executed. That's why they are even necessary for functions which are called without arguments.

Arguments of functions

Arguments are values provided to a function when the function is called. We will see more about them soon.

.1. Defining Functions

In Section 3.5 we have learnt how to apply or call functions. So let's remember the example calculating the GC-percentage of a DNA sequence.

>>> float(count(cds, 'G') + count(cds, 'C')) / len(cds)
      

This calculates the gc percentage of the specific DNA sequence cds, but we can use the same formula to calculate the gc percentage of other DNA sequences. The only thing to do is to replace cds by the new DNA sequence in the formula. But it is not very convenient to remember the formula and retype it all the time. It would be much easier to type the following instead.

>>> gc('ATGCAT')
0.33333333333333331
>>> gc(cds)
0.54460093896713613
      

The only thing we have to remember is the name of the new function and its use.

Abstraction

The possibility to define such new function executing tasks specified by yourself, is an abstraction feature, provided by all high level programming languages.

Important

It is also important to notice that functions have to be defined before they are called. You can not use something that is not defined.

Here is the syntax of such a new definition in Python:

>>> from string import *

>>> def gc(seq):
...     return float(count(seq, 'G') + count(seq, 'C')) / len(seq)
      

Let's have a closer look at this definition. Figure 8.1 illustrates the structure of a function definition.

Figure 8.1. Function definitions

def and return are basic instructions.

Basic instruction

Basic instructions are statements that define the language rules and the semantic of Python. They constitute the basic set of instructions of Python. Each basic instruction has its own syntax that you have to learn in order to master the programming language.

The return basic instruction is used to return the result of a function back, in our example the value of the GC percentage of the specified DNA sequence.

The def basic instruction indicates to Python that a function definition follows. It has to be followed by the new function name and a comma separated list of parameter names enclosed into parentheses.

Parameter

Parameters are variable names. When the function is called they are bound in the same order to the arguments given.

The body of a function contains the piece of code needed to execute the subtask of the function. In the example above, the body contains only the return statement. Here is a more complex example that excludes ambiguous bases from the GC percentage calculation.

>>> from string import *

>>> def gc(seq):
...    nbases = count(seq, 'N')
...    gcpercent = float(count(seq, 'G') + count(seq, 'C')) / (len(seq) - nbases)
...    return gcpercent
      

In this example the body of the function contains three instructions (2 assignments and the return statement). The body of a function follows the definition line and is written as an indented block initiated by a colon.

Block

Blocks are structure elements of a program, that are used to group instructions. They are initiated by a colon and are separated from the rest of the code by the same indentation step in Python.

In our example, the function body is written as a block to separate it from the rest of the program. The Python interpreter used it to detect where the function body starts and ends.

Important

In other programming languages special words or characters are used to indicate the begin and the end of blocks and the indentation is only used to make the code readable for humans. In Python the indentation is used explicitly to do this. So in the above example of a function definition the end of the body is detected when the next line starts without any indentation step. This is also illustrated in Figure 8.2.

Example 8.1. More complex function definition

>>> from string import *

>>> def gc(seq):
...    nbases = count(seq, 'N')
...    gcpercent = float(count(seq, 'G') + count(seq, 'C')) /  \
                   (len(seq) - nbases)
...    return gcpercent
...
>>> gc('ATGCN')
0.5
	

Figure 8.2. Blocks and indentation

1関数とは
 
にはあらかじめ用意されている組込関数と自分で作る関数
 と2種類ある。利用の方法は全く同じである.

 名前(引数)の形式で書かれる
 len(x)    引数Xについて何かをする lenは組み込み関数
 >>> s=[1,2,3,4,5,6]
 >>> len(s)
 6
 
 関数のメリットは
 1.繰り返し作業をコード化する
 2.処理の内容が短縮される
 3.処理の変更が容易になる。

 自分で関数を作る
 defステートメント
 
  >>> def hello():
     
print ('hello python')
 >>> hello()

 hello python

 6
 
 2。メソッドとは
 

  名前。名前(引数)のような形式をとる。データ型(オブジェクト)が特別に 
 持っている命令のこと。

 オブジェクト ドット メソッドの順で書く
 >>> address="mizonokuti,takatuku,kawasakisi,kanagawaken,japan"
 >>> address.split(",")

 ['mizonokuti', 'takatuku', 'kawasakisi', 'kanagawaken', 'japan']

  >>> 'hello'.
upper()
  'HELLO'
  
3。 関数を作る
  
  (1)点数評価
 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
 
 低い
  
  
 
 (2)足し算
 def purasu(x,y):
       print(x+y)
 
 purasu(23,26)
  

 49
 
 
()の中に仮引数、実引数、空が入る
 引数

 

 (3)回数
 say_moo() 鳴く回数を引数として加えるに
                 は、どうするか
 
                 考える


 def saymo() :
     for i in range(3):
         print ('モ-')
  
 >>> saymo()
 モー
 モー
 モー
  、 演算子を使用して1行に出力
 >>> def saymo():
      for i in range
(3) :
         print( 'モー',)
 >>> saymoo()
 モー  モー モー

  
i in range(3):はメソッドを実行するときに与え
                   られた引数 
 
           を(メソッドの中から)指し示すための
           変数。引数は3。

 オブジェクトsaymoが名詞で、メソッドprint(’
  モー’)が  
 動詞であるならば、引数for i in range(3)は副
  詞。

 
(4)土地建物長期譲渡で取得する資金額を
         計算する関数。
 
 
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で抽象化                                                      
 

 (5)局所変数 Local variable
 
 def duble_times():
     num=0
     num=input('>')
     num=int(num)
     num_times2=int(num)*2
     print (num,'の2倍は',num_times2)
 
 >>> duble_times()
 >34

 34 の2倍は 68

 変数1 numと  変数2 num_times_2 と二
           っあります。
 この二つは局所変数。メソッドの内部に
  のみ存在する関数。 

 

  
 >>>duble_times()
 >56
 56の2倍は 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を外部から使用できません・
 メソッドの中 でのみ有効。

 
 (6) 返り値

 
が呼んだコードに返
      す。
 print はプログラムが画面に対して情報を出
     力する文。

 >>> def say_moo() :
      print
('モー’)
 
 >>> say_moo
()
  モー
 >>> print( say_moo()) < 
say_moo()メソッドが出力したモ
                        ノ、
 モー
 None         < 
print が出力したモノ、。printはいつ
                     もNoneを返
す。
            <
文字列を返すようにしたければ、それをメソッドに適用
                    
 >>> def say_moo
():
        print
('モー’)
        print
('yellow orange’)
 
 >>> say_moo
()
 モー
 yellow orange

 (7)
 return文を使う.。
 
 return文は関数の中で使い、カッコを使わな
     いで関数の 外に受け渡したいデータをそのまま記述。
  
    
    
 >>> def f(a,b):
          c = a +b
           return c
 >>> f(7,8)
 15
 
 >>> def times(x,y):            <変数オブジェクトを作成し、関数 
                              名に代入
          return x*y          <
呼び出された場合に実行されるボ 
                             ディ 
 
 >>> times(34,67)          <
カッコ内に引数を指定し、呼び出す。                      
    2278

 def food():
     name=input
('名前入力>')
     if name
=='鈴木':
            return
('おもち')
     if name
=='山田' :
            return ('ベーコン')
 
 >>> food
()
 名前入力>鈴木
 
 'おもち'
 
 >>> food
()
 
名前入力>山田
 

 'ベーコン'
 

 (8)return文を使わない。
 
 def food():
     name=input
('名前入力>')
     if name
=='鈴木':
            print
('おもち')
     if name=='山田' :
            print
('ベーコン')
 
 >>> food()
 
名前入力>鈴木

 'おもち'

 >>> food
()
 
名前入力>山田

 'ベーコン'
 
 (8)同じコードの繰り返す例:

 次のコードを読んでください
 print ('
今日は、私の実験のためにお時間をと
って、')
 print
('いただき、ありがとうございます。この
実験は、')
 print
('人々が日本料理に対してどう感じてい
るか')
 print
( 'に関するものです。日本料理について
考え')
 print
( 'すべての質問に対して、yesかnoかで
正直に')
 print
( '答えてください。この実験は簿記学と
は関係')
 print
(’答えは無視し
てしまいま   
   す。ありません。')
 # いくつかの質問をしますが
 good_answer = False  
 while(not good_answer) :
  print
( '天ぷらは好きですか?')
  answer =input
('>')
  if answer
== ('yes' or answer == 'no') :
 good_answer =
True
else :
print
( ' "yes" か "no"でお答えくださ
い。')
 good_answer =
False
 while (not good_answer) :                     
   
 繰り返し部分
print( 'フグ料理は好きですか?')
answer = input('>')
if answer == ('yes' or answer == 'no') :
good_answer = True
else :
print
( ' " yes" か"no" でお答えくださ
い。')
 #この回答には注目します
 good_answer =
False
 while (not good_answer)
print
('簿記の学習は好きですか?')
answer = input('>')
if answer == ('yes' or
answer == 'no')  :
good_answer = True
else :
print(
' " yes" か "no "でお答えくださ
い。')
 good_answer =
False
 while (not good_answer)
print( '焼き肉料理
は好きですか?')
answer = input
('>')
if answer == ('yes' or
answer == 'no') :
good_answer =
True
else :
print
(' " yes "か "no" でお答えくださ
い。
')
 print 'あともう少し質問させてください'
 good_answer = False                          

while (not good_answer)
print
( 'そば料理は好きですか?')
answer = input
('>')
if answer == ('yes' or answer == 'no') :
good_answer =
True
else :
print
( ' " yes "か" no "でお答えくださ
い。')
 # 日本料理に関しては他にもたくさんの質問
をします。
 print()
 print
('デブリーフィング:' #実験後、被験者に
その目的  
    や理由を明かすこと)
 print
( 'この実験へのご協力を感謝します。実
は、この 
     実')
 print
('験は日本料理とは何の関係もありませ
ん')
 print(
'この実験は簿記学への関心に関する実
験だっ'
)
 print
('日本料理は、より正直に答えら')
 print
('られるよう、あなたのガードをはづすた
     めに聞い
     た')
 print
('に過ぎません。本当にありがとうござい
     ました。')
 print()
 print
(book_keeping)
(クリス著・はじめてのプログラミング参照


(9)関数で上記のコードを修正する
 
 
 これで自分のメソッドを作ることを学だの
   で、ここで心理学の実験プログラムを修正。
 
   あいさつ文の関数

 
 
 
def aisatu() :
        print
( '今日は、私の実験のためにお時間をとって、’)
        print
( 'いただき、ありがとうございます。この実験
     
    は、’)
        print
( '人々が日本料理に対してどう感じているか’)
        print
('に関するものです。日本料理について考え’)
        print
('すべての質問に対して、yesかnoかで正直
         に’)

        print
( '答えてください。この実験は簿記学習とは関
         係’)
        print
('ありません。’)
 aisatu()と入力すると、あいさつ文が画面に出力されます。
 
 質問文
  
>>> q1 ='天ぷら'
 >>> q2
='フグ'
 >>> q3
= '簿記学習はすきですか?'
 >>> q4
= '焼き肉'
 >>> q5
= 'そば'
 >>> q6 =
'すし'
 >>> q7
= 'うなぎ'
 >>> q10
='はお好きですか'
 >>>print(q1+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 ('にすぎません。本当に有難うございました。’)

 練習問題 askメソッドを修正してください 
 good_answer,answerの二つの変   
 数を取り除くこと。ループから抜けるのにreturn文を使う

  (10)フィナボッチ級数を任意の境界値ま書きだす関数

 def fib(n):              <キーワードdefは関数を定義
***nまでのフィナボッチ級数を表示する*** <文字列リテラル、関数のドキュメ
                               ン
                                テーション文字列、docstring
                                docstringはよい習慣。 
<関数本体が始まる
                              <本体はインデントして始まる。

     a,b=0,1                     <ローカル変数a,b

    while b < n :
     print(b,)
       a,b=b,a+b

 >>> fib(2000)                     <関数をコールするときに与えら
                               れる実パラメータ[引数)2000
       
関数を定義すると、この関数名の値(実体)の型がユーザ定義関数。この
       値を別の名前に代入すればその名前も関数として使えるようになる。

>>> fib
<function fib at 0x0106B270>
>>> f=
fib
>>> f(100)
1
1
2
3
5
8
13
21
34
55
89

def parr(vol,state='stiff',act='voo',type='norw'): <引数
print('this par',act,)
print('if you',vol,'volta')
print('lovely',type)
print('tts',state ,'!')
>>> parr(10)                     <引数 10 はvol
this par voo
if you 10 volta
lovely norw
tts stiff !

(11)メッソドと関数との用語の使い方について認識 す


. メソッド
 データ型(オブジェクト)が特別に持っている命令のこと。

オブジェクト ドット メソッドの順で書く
 >>> address="mizonokuti,takatuku,kawasakisi,kanagawaken,japan"
 >>> address.split(",")

['mizonokuti', 'takatuku', 'kawasakisi', 'kanagawaken', 'japan']

  

 (12)関数に説明文を加える

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

(13)キーワード引数

 キーワードの順序に関係しない

 >>> def greet(a):
       "引数を設定"
       print("hello" + a)

 


 >>> greet(" taro !")
    hello taro !
 
 >>> def greet(a , b):
     "引数を2個設定"
     print("hello "+a+b)

 
 
>>> greet("taro !"," hanako !")
    hello taro ! hanako !

 
 
 
 >>> greet(a="python",b=" ruby !")   関数を名前付き変数で呼び出す
    hello python ruby !
   >>> def greet(a="python !"):
       "デフォルト引数をpythonとする"
       print("hello " + a)

 
 >>> greet()
 
hello python !
 
 >>> greet("ruby !")  引数rubyを指定する
    hello ruby !

 リストのメソッド

  第8章リストを参照 

ホーム     戻る


      

ホーム     戻る