函數的返回值：

可以返回任意類型

沒有return的話返回：None

return返回一次就終止函數的運行

函數的使用：

必須先定義，然後再調用

函數的定義：跟變量定義相似，如果沒有事先定義就調用的話相當於在引用一個不存在的變量名

# #定義階段
# def foo():
#     print(‘from foo‘)
#     bar()
#
# def bar():
#     print(‘from bar‘)
#
# #調用階段
# foo()


#定義階段:只檢測語法，不執行代碼
# def func():
#    if 1>2
#        print(‘hahahahahahah‘)
 



def func(): #語法沒問題，邏輯有問題，引用一個不存在的變量名

函數參數：

實參與形參（實際傳入的參數叫做實參）

位置參數：按照從左到右的順序依次定義的參數

def foo(x,y):
    print(x)
    print(y)
#按位置定義的形參,必須被傳值，多一個不行，少一個也不行，按位置對應傳入
 foo(1,2)

關鍵字參數：實參在定義時，按照key=value形式定義

def foo(x,y):
     print(x)
     print(y)
foo(y=10,x=1)
 foo(y=10,x=1) #
 
關鍵字參數可以不用像位置實參一樣與形參一一對應，需要指名道姓地傳值

註意：

問題一：位置實參必須在關鍵字實參的前面
問題二：實參的形式既可以用位置實參又可以是關鍵字實參，但是一個形參不能重復傳值

默認參數：在定義函數階段，就已經為形參賦值,定義階段有值，調用階段可以不用傳值

def func(x,y=10):   #形參中給了默認值，實參中可以不用傳值，那麽會按照默認值運行
     print(x)             #傳值的話就會按傳入的值運行    
     print(y)


 func(1,20)
 func(1)

#形參的應用：值經常變化的需要定義成位置形參，
# 值大多數情況下都一樣，需要定義成默認參數

默認參數註意問題：

　　一、默認參數需要註意的問題一：必須放在位置形參後面
　　二、默認參數需要註意的問題二：默認參數通常要定義成不可變類型
　　三、默認參數需要註意的問題三：默認參數只在定義階段被賦值一次

可變長參數： 可變長指的是實參的個數不固定
#按位置定義的可變長度的實參：*
#按關鍵字定義的可變長度的實參：**

def func(x,y,*args): #x=1,y=2,args=(3,4,5,6)#*號接收x,y以外的參數，以元組的形式賦值給args
     print(x,y)
     print(args)

 func(1,2,3,4,5,6)




 def func(x,y,*args):  #args=(3,4,5,6)
     print(x,y)
     print(args)

 func(1,2,*(3,4,5,6)) #*號後拆開即為foo(1,2,3,4,5,6)


 def func(x,y,z):
     print(x,y,z)

 func(1,*(2,3)) #func(1,2,3)#同上
 func(*(2,3)) #func(2,3)



 def func(x,y,**kwargs): #x=1,y=2,kwargs={‘a‘:1,‘b‘:3,‘z‘:3}#**用來接收關鍵字參數，並以字典形式賦值給kwargs
     print(x,y)
     print(kwargs)

 func(1,y=2,z=3,a=1,b=3)#關鍵字參數必須放在位置參數後


 def func(x,y,**kwargs): #x=1,y=2,**kwargs=**{‘a‘:1,‘b‘:3,‘z‘:3}
     print(x,y)
     print(kwargs)

 func(1,y=2,**{‘a‘:1,‘b‘:3,‘z‘:3}) #**拆開即為func(1,y=2,z=3,b=3,a=1)


 def func(x,y=1,z=1):
     print(x,y,z)

 func(**{‘y‘:2,‘x‘:1,‘z‘:3}) #


 def wrapper(*args,**kwargs): #可以接受任意形式，任意長度的參數
     print(args)
     print(kwargs)


 wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3)

命名關鍵字參數:定義在*後的形參，這類形參，必須被傳值，而且要求實參必須是以關鍵字的形式來傳值

函數的嵌套使用：

定義：

def f1():
def f2():
def f3():
print(‘from f3‘)
print(‘from f2‘)
f3()
print(‘from f1‘)
f2()
# print(f1)
f1()

 def max2(x,y):
     if x > y:
         return x
     else:
         return y

 def max4(a,b,c,d):
     res1=max2(a,b) #23
     res2=max2(res1,c) #23
     res3=max2(res2,d) #31
     return res3


 print(max4(11,23,-7,31))

函數是第一類對象： 指的是函數可以被當做數據傳遞

def func():
    print(‘from func‘)

#可被引用
f=func

#可以當做函數的參數
def func():
    print(‘from func‘)
def foo(x):
    print(x)
    x()
foo(func)

#可以當做函數的返回值
def foo():
    print(‘from foo‘)
def bar():
    return foo
f=bar()
print(f)
print(foo)

x=0
def f1():
    x=1
    def f2():
        # x=2
        print(x)
    return f2
f=f1()
# print(f)
 f()



#可以當做容器類型的元素
def select():
    print(‘select function‘)
func_dic={
    ‘select‘:select,
}

# print(func_dic[‘select‘])
# func_dic[‘select‘]()






#
# def select():
#     print(‘select func‘)
#
# def delete():
#     print(‘delete func‘)
#
# def change():
#     print(‘change func‘)
#
# def add():
#     print(‘add func‘)
#
#
# while 1:
#     cmd=input(‘>>: ‘).strip()
#     if not cmd:continue
#     if cmd == ‘select‘:
#         select()
#     elif cmd == ‘delete‘:
#         delete()
#     elif cmd == ‘change‘:
#         change()
#     elif cmd == ‘add‘:
#         add()
#     else:
#         print(‘無效的命令‘)

名稱空間：存放名字與值的綁定關系

名稱空間分為三種
內置名稱空間：python解釋器自帶的名字，python解釋器啟動就會生成

全局名稱空間：文件級別定義的名字都會存放與全局名稱空間，執行python文件時會產生

局部名稱空間:定義在函數內部的名字，局部名稱空間只有在調用函數時才會生效，函數調用結束則失效

三者的加載順序：內置名稱空間->全局名稱空間->局部名稱空間

取值：局部名稱空間->全局名稱空間->內置名稱空間

作用域：作用範圍
　　　　全局作用域：內置名稱空間與全局名稱空間的名字屬於全局範圍，
　　在整個文件的任意位置都能被引用，全局有效
　　　　局部作用域：局部名稱空間的名字屬於局部範圍，
　　只在函數內部可以被引用，局部有效

Python編程（四）函數