python函數

默認參數必須放在最后面，否則會報：

SyntaxError: non-default argument follows default argument

# 可寫函數說明
def printinfo( age=35,name):   # 默認參數不在最后，會報錯
    "打印任何傳入的字符串"
    print("名字: ", name)
    print("年齡: ", age)
    return

>>> def func(country,province,**kwargs):
...     print(country,province,kwargs)
... 
>>> func("China","Sichuan",city = "Chengdu", section = "JingJiang")
China Sichuan {'city': 'Chengdu', 'section': 'JingJiang'}
>>>

lambda 匿名函數也是可以使用"關鍵字參數"進行參數傳遞
```
>>> g= lambda x,y : x**2+y**2
>>> g(2,3)
13
>>> g(y=3,x=2)
13
```
同樣地，lambda 匿名函數也可以設定默認值
```
>>> g= lambda x=0,y=0 : x**2+y**2
>>> g(2,3)
13
>>> g(2)
4
>>> g(y=3)
9
```
注意：如果只打算給其中一部分參數設定默認值，那么應當將其放在靠后的位置（和定義函數時一樣，避免歧義），否則會報錯。
關于可更改與不可更改類型，以及其它語言的值類型與引用類型的介紹，一直一來感覺都不太嚴謹，說法是否正確有待驗證。
簡單的說就是，不可更改類型傳到函數里重新賦值后，兩次輸出值不一樣，而可更改類型傳到函數里對對象的"屬性" 重新賦值后輸出值一樣。

這里照搬一下例子：
```
# 可寫函數說明
def changeme( mylist ):
   "修改傳入的列表"
   mylist.append([1,2,3,4])
   print ("函數內取值: ", mylist)
   return
 
# 調用changeme函數
mylist = [10,20,30]
changeme( mylist )
print ("函數外取值: ", mylist)
```
請注意：上面特意用了引號標準的部分，對可變類型或者引用的操作修改的是傳過來的對象的屬性。

可以這么理解(例子有點隨意)：我在畫畫，小明來了說他也要畫，我讓他和我一起畫，他如果和我在同一個畫板上畫，那么我們兩的畫就會同時改變。而如果他說不，我要另外用一塊畫板，然后重新拿了塊畫板畫起來了，那么我們兩的畫自然就不一樣了。

同理可更改類型的屬性進行操作，這只是對引用的內存塊里面的值進行操作，引用并沒變，自然所有引用它的對象的值都變了。而對不可更改的對象進行操作，因為它引用的內存塊只是對應一個固定的值，不能進行修改，要重新復制實際上就是更新引用。

如果我們運行下面的例子，對可更改類型的引用進行修改，結果就不一樣了。
```
# 可寫函數說明
def changeme( mylist ):
   "修改傳入的列表"
   mylist = [1,2,3,4]
   print ("函數內取值: ", mylist)
   return
 
# 調用changeme函數
mylist = [10,20,30]
changeme( mylist )
print ("函數外取值: ", mylist)
```
結果
```
函數內取值:  [1, 2, 3, 4]
函數外取值:  [10, 20, 30]
```
對于變量作用域，變量的訪問以 L（Local） –> E（Enclosing） –> G（Global） –>B（Built-in） 的規則查找，即：在局部找不到，便會去局部外的局部找（例如閉包），再找不到就會去全局找，再者去內建中找。
觀察以下幾個例子，均從內部函數輸出變量 x：

1. 局部作用域
```
x = int(3.3)

x = 0
def outer():
    x = 1
    def inner():
        x = 2
        print(x)
    inner()

outer()
```
執行結果為 2，因為此時直接在函數 inner 內部找到了變量 x。

2.閉包函數外的函數中
```
x = int(3.3)

x = 0
def outer():
    x = 1
    def inner():
        i = 2
        print(x)
    inner()

outer()
```
執行結果為 1，因為在內部函數 inner 中找不到變量 x，繼續去局部外的局部——函數 outer 中找，這時找到了，輸出 1。

3.全局作用域
```
x = int(3.3)
x = 0
def outer():
    o = 1
    def inner():
        i = 2
        print(x)
    inner()

outer()
```
執行結果為 0，在局部（inner函數）、局部的局部（outer函數）都沒找到變量 x，于是訪問全局變量，此時找到了并輸出。

4. 內建作用域
```
x = int(3.3)
g = 0
def outer():
    o = 1
    def inner():
        i = 2
        print(x)
    inner()

outer()
```
執行結果為 3，在局部（inner函數）、局部的局部（outer函數）以及全局變量中都沒有找到變量x，于是訪問內建變量，此時找到了并輸出。

例 :

a = 10
def sum ( n ) :
   n += a
   print ('a = ', a, end = ' , ' )
   print ( 'n = ', n )
  
sum(3)

輸出 :

a =  10 , n =  13

如果引用了還沒更新的值則會報錯 :

a = 10
def sum ( n ) :
   n += a
   a = 11
   print ('a = ', a, end = ' , ' )
   print ( 'n = ', n )
  
sum(3)

輸出 :

...

UnboundLocalError: local variable 'a' referenced before assignment

可以加上 global 引用以更新變量值 :

a = 10
def sum ( n ) :
   global a
   n += a
   a = 11
   print ('a = ', a, end = ' , ' )
   print ( 'n = ', n )

sum ( 3 )
print ( '外 a = ', a )

輸出:

a = 11 , n = 13 外 a = 11

def hello () :
  print ("Hello, world!")

def execute(f):
  "執行一個沒有參數的函數"
  f()

execute(hello)

輸出：

Hello, world!

可以通過函數名.__doc__ 的方式來顯示函數的說明文檔，感覺這個如果在閱讀比較大的程序時應該會有用，同時也在提示自己在寫函數時注意添加文檔說明。
```
def add(a,b):
    "這是 add 函數文檔"
    return a+b

print (add.__doc__)
```
輸出結果為：
```
這是 add 函數文檔
```
函數返回值的注意事項: 不同于 C 語言，Python 函數可以返回多個值，多個值以元組的方式返回:
```
def fun(a,b):    
    "返回多個值，結果以元組形式表示"
    return a,b,a+b
print(fun(1,2))
```
輸出結果為：
```
(1, 2, 3)
```

在不改變當前函數的情況下, 給其增加新的功能:

def log(pr):#將被裝飾函數傳入
    def wrapper():
        print("**********")      
        return pr()#執行被裝飾的函數
    return wrapper#將裝飾完之后的函數返回（返回的是函數名）
@log
def pr():
    print("我是小小洋")

pr()

回調函數和返回函數的實例就是裝飾器。

1.內部函數，不修改全局變量可以訪問全局變量
```
a = 10
def test():
    b = a + 2 #僅僅訪問全局變量 a
    print(b)
test()
```
輸出結果為：
```
12
```
2.內部函數，修改同名全局變量，則python會認為它是一個局部變量（同教程最后一個例子）
```
#!/usr/bin/python3
 
a = 10
def test():
    a = a + 1 #修改同名的全局變量，則認為是一個局部變量
    print(a)
test()
```
3.在內部函數修改同名全局變量之前調用變量名稱（如print sum），則引發Unbound-LocalError

測試代碼如下:

num = 20
def outer():
    num = 10
    def inner():
        global num
        print (num)
        num = 100
        print (num)
    inner()
    print(num)
outer()
print (num)

結果如下：

class demo:
    name = ""
    def _init_(self):
        self.ex()
        self.start()
    def inputName(self):
        global name
        name = input("輸入您的姓名：")
    def getFirstName(self):
        if len(name) <= 0:
            x = "別鬧！請輸入姓名！"
            return x
        else:
            x = name[0]
            return x
    def getLastName(self):
        if len(name) <= 1:
            y = "別鬧！長度不夠！"
            return y
        else:
            y = name[1:]
            return y
myname = demo()
myname.inputName()
print(myname.getFirstName())
print(myname.getLastName())

函數的參數分為形參和實參。
1. 什么是形參

對于函數來說，形式參數簡稱形參，是指在定義函數時，定義的一個變量名。

下面的代碼中，x、y、z 就是形參。
```
#定義函數

def foo(x, y, z):
      print("x=", x)
      print("y=", y)
      print("z=", z)

#調用函數
foo(1,3,5)                #此處的1,3,5是實參
```
輸出結果：
```
x= 1
y= 3
z= 5
```
形參的作用：是用來接收調用函數時輸入的值。

2. 什么是實參

對于函數來說，實際參數簡稱實參。

是指在調用函數時傳入的實際的數據，這會被綁定到函數的形參上。

函數調用時，將值綁定到變量名上，函數調用結束，解除綁定，并且實參將不再存在于程序中。
```
foo(5,2,0)
```
上面的 5、 2 和 0 都是實參。
在編寫函數的過程中，可以顯式指定函數的參數類型及返回值類型：
```
#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

def function_demo(param_A: int, param_B: float, param_C: list, param_D: tuple) -> dict:
    pass
```
這種 “將數據類型寫死在代碼中” 的行為在集成開發環境/代碼編輯器時尤為方便，通過顯式地指定函數的參數類型和返回值，能夠讓智能補全組件提前獲知標識符的數據類型，提供有利的輔助開發功能。

1.向函數傳遞的函數本身可以是有參數的:

def demo(*p):
    i=0
    for var in p:
        var(i)
        i+=1
def d1(i):
    print("這里是第一個子函數,輸入的數是",i)
def d2(i):
    print("這里是第二個子函數,輸入的數是",i)
def d3(i):
    print("這里是第三個子函數,輸入的數是",i)
def d4(i):
    print("這里是第四個子函數,輸入的數是",i)
demo(d1,d2,d3,d4)

上面的代碼執行起來沒問題。

2.就算你的函數是有參數的，將這個函數傳遞給另一個函數的時候也不能加參數，還是上面的例子:

demo(d1(7),d2,d3,d4)

這樣就會報錯，因為此時 d1(7) 就是 d1() 的返回值，是不可以在方法內部傳遞參數并且調用。

posted @ 2020-11-28 10:22 富貴兒- 閱讀(190) 評論(0) 收藏舉報

刷新頁面返回頂部

富貴兒-

python函數

公告